parsing/docstrings.cmx \
parsing/parse.cmi
parsing/parse.cmi : \
- parsing/parsetree.cmi
+ parsing/parsetree.cmi \
+ parsing/longident.cmi
parsing/parser.cmo : \
parsing/syntaxerr.cmi \
parsing/parsetree.cmi \
parsing/parser.cmi
parsing/parser.cmi : \
parsing/parsetree.cmi \
+ parsing/longident.cmi \
parsing/location.cmi \
parsing/docstrings.cmi \
parsing/camlinternalMenhirLib.cmi
parsing/parsetree.cmi \
parsing/longident.cmi \
parsing/location.cmi \
+ utils/clflags.cmi \
parsing/asttypes.cmi \
parsing/printast.cmi
parsing/printast.cmx : \
parsing/parsetree.cmi \
parsing/longident.cmx \
parsing/location.cmx \
+ utils/clflags.cmx \
parsing/asttypes.cmi \
parsing/printast.cmi
parsing/printast.cmi : \
typing/types.cmi \
typing/path.cmi \
parsing/asttypes.cmi
+typing/cmt2annot.cmo : \
+ typing/types.cmi \
+ typing/typedtree.cmi \
+ typing/tast_iterator.cmi \
+ typing/stypes.cmi \
+ typing/path.cmi \
+ typing/oprint.cmi \
+ parsing/location.cmi \
+ typing/ident.cmi \
+ typing/envaux.cmi \
+ typing/env.cmi \
+ file_formats/cmt_format.cmi \
+ parsing/asttypes.cmi \
+ typing/annot.cmi
+typing/cmt2annot.cmx : \
+ typing/types.cmx \
+ typing/typedtree.cmx \
+ typing/tast_iterator.cmx \
+ typing/stypes.cmx \
+ typing/path.cmx \
+ typing/oprint.cmx \
+ parsing/location.cmx \
+ typing/ident.cmx \
+ typing/envaux.cmx \
+ typing/env.cmx \
+ file_formats/cmt_format.cmx \
+ parsing/asttypes.cmi \
+ typing/annot.cmi
typing/ctype.cmo : \
typing/types.cmi \
typing/type_immediacy.cmi \
typing/subst.cmi \
typing/printtyp.cmi \
typing/path.cmi \
+ parsing/location.cmi \
typing/ident.cmi \
typing/env.cmi \
parsing/asttypes.cmi \
typing/subst.cmx \
typing/printtyp.cmx \
typing/path.cmx \
+ parsing/location.cmx \
typing/ident.cmx \
typing/env.cmx \
parsing/asttypes.cmi \
typing/subst.cmi \
typing/printtyp.cmi \
typing/primitive.cmi \
+ typing/predef.cmi \
typing/path.cmi \
typing/oprint.cmi \
typing/mtype.cmi \
typing/subst.cmx \
typing/printtyp.cmx \
typing/primitive.cmx \
+ typing/predef.cmx \
typing/path.cmx \
typing/oprint.cmx \
typing/mtype.cmx \
file_formats/cmi_format.cmi
typing/predef.cmo : \
typing/types.cmi \
+ typing/type_immediacy.cmi \
typing/path.cmi \
parsing/parsetree.cmi \
parsing/location.cmi \
typing/predef.cmi
typing/predef.cmx : \
typing/types.cmx \
+ typing/type_immediacy.cmx \
typing/path.cmx \
parsing/parsetree.cmi \
parsing/location.cmx \
parsing/longident.cmi \
parsing/location.cmi \
typing/ident.cmi \
+ utils/clflags.cmi \
parsing/asttypes.cmi \
typing/printtyped.cmi
typing/printtyped.cmx : \
parsing/longident.cmx \
parsing/location.cmx \
typing/ident.cmx \
+ utils/clflags.cmx \
parsing/asttypes.cmi \
typing/printtyped.cmi
typing/printtyped.cmi : \
typing/typedecl.cmi \
typing/typecore.cmi \
typing/subst.cmi \
- typing/stypes.cmi \
typing/printtyp.cmi \
typing/predef.cmi \
typing/path.cmi \
typing/typedecl.cmx \
typing/typecore.cmx \
typing/subst.cmx \
- typing/stypes.cmx \
typing/printtyp.cmx \
typing/predef.cmx \
typing/path.cmx \
typing/typedtree.cmi \
typing/typedecl.cmi \
typing/subst.cmi \
- typing/stypes.cmi \
typing/rec_check.cmi \
typing/printtyp.cmi \
typing/printpat.cmi \
typing/path.cmi \
parsing/parsetree.cmi \
typing/parmatch.cmi \
- typing/oprint.cmi \
typing/mtype.cmi \
utils/misc.cmi \
parsing/longident.cmi \
typing/typedtree.cmx \
typing/typedecl.cmx \
typing/subst.cmx \
- typing/stypes.cmx \
typing/rec_check.cmx \
typing/printtyp.cmx \
typing/printpat.cmx \
typing/path.cmx \
parsing/parsetree.cmi \
typing/parmatch.cmx \
- typing/oprint.cmx \
typing/mtype.cmx \
utils/misc.cmx \
parsing/longident.cmx \
typing/typedtree.cmi \
typing/typedecl_variance.cmi \
typing/typedecl_unboxed.cmi \
+ typing/typedecl_separability.cmi \
typing/typedecl_immediacy.cmi \
typing/type_immediacy.cmi \
typing/subst.cmi \
typing/printtyp.cmi \
typing/primitive.cmi \
typing/predef.cmi \
+ parsing/pprintast.cmi \
typing/path.cmi \
parsing/parsetree.cmi \
typing/oprint.cmi \
typing/includecore.cmi \
typing/ident.cmi \
typing/env.cmi \
- typing/datarepr.cmi \
typing/ctype.cmi \
utils/config.cmi \
utils/clflags.cmi \
typing/typedtree.cmx \
typing/typedecl_variance.cmx \
typing/typedecl_unboxed.cmx \
+ typing/typedecl_separability.cmx \
typing/typedecl_immediacy.cmx \
typing/type_immediacy.cmx \
typing/subst.cmx \
typing/printtyp.cmx \
typing/primitive.cmx \
typing/predef.cmx \
+ parsing/pprintast.cmx \
typing/path.cmx \
parsing/parsetree.cmi \
typing/oprint.cmx \
typing/includecore.cmx \
typing/ident.cmx \
typing/env.cmx \
- typing/datarepr.cmx \
typing/ctype.cmx \
utils/config.cmx \
utils/clflags.cmx \
typing/types.cmi \
typing/typedtree.cmi \
typing/typedecl_variance.cmi \
+ typing/typedecl_separability.cmi \
typing/typedecl_immediacy.cmi \
typing/path.cmi \
parsing/parsetree.cmi \
typing/types.cmi \
typing/ident.cmi \
typing/env.cmi
+typing/typedecl_separability.cmo : \
+ typing/types.cmi \
+ typing/typedecl_properties.cmi \
+ parsing/location.cmi \
+ typing/env.cmi \
+ typing/ctype.cmi \
+ utils/config.cmi \
+ typing/btype.cmi \
+ parsing/asttypes.cmi \
+ typing/typedecl_separability.cmi
+typing/typedecl_separability.cmx : \
+ typing/types.cmx \
+ typing/typedecl_properties.cmx \
+ parsing/location.cmx \
+ typing/env.cmx \
+ typing/ctype.cmx \
+ utils/config.cmx \
+ typing/btype.cmx \
+ parsing/asttypes.cmi \
+ typing/typedecl_separability.cmi
+typing/typedecl_separability.cmi : \
+ typing/types.cmi \
+ typing/typedecl_properties.cmi \
+ parsing/location.cmi \
+ typing/ident.cmi \
+ typing/env.cmi
typing/typedecl_unboxed.cmo : \
typing/types.cmi \
typing/predef.cmi \
typing/typecore.cmi \
typing/typeclass.cmi \
typing/subst.cmi \
- typing/stypes.cmi \
typing/printtyp.cmi \
typing/path.cmi \
parsing/parsetree.cmi \
+ parsing/parse.cmi \
typing/mtype.cmi \
utils/misc.cmi \
parsing/longident.cmi \
typing/ctype.cmi \
utils/config.cmi \
file_formats/cmt_format.cmi \
+ typing/cmt2annot.cmo \
file_formats/cmi_format.cmi \
utils/clflags.cmi \
parsing/builtin_attributes.cmi \
typing/typecore.cmx \
typing/typeclass.cmx \
typing/subst.cmx \
- typing/stypes.cmx \
typing/printtyp.cmx \
typing/path.cmx \
parsing/parsetree.cmi \
+ parsing/parse.cmx \
typing/mtype.cmx \
utils/misc.cmx \
parsing/longident.cmx \
typing/ctype.cmx \
utils/config.cmx \
file_formats/cmt_format.cmx \
+ typing/cmt2annot.cmx \
file_formats/cmi_format.cmx \
utils/clflags.cmx \
parsing/builtin_attributes.cmx \
utils/misc.cmi \
parsing/longident.cmi \
parsing/location.cmi \
+ utils/identifiable.cmi \
typing/ident.cmi \
+ utils/config.cmi \
parsing/asttypes.cmi \
typing/types.cmi
typing/types.cmx : \
utils/misc.cmx \
parsing/longident.cmx \
parsing/location.cmx \
+ utils/identifiable.cmx \
typing/ident.cmx \
+ utils/config.cmx \
parsing/asttypes.cmi \
typing/types.cmi
typing/types.cmi : \
parsing/parsetree.cmi \
parsing/longident.cmi \
parsing/location.cmi \
+ utils/identifiable.cmi \
typing/ident.cmi \
parsing/asttypes.cmi
typing/typetexp.cmo : \
bytecomp/instruct.cmi \
typing/ident.cmi \
typing/env.cmi \
+ lambda/debuginfo.cmi \
utils/config.cmi \
+ utils/clflags.cmi \
parsing/asttypes.cmi \
bytecomp/bytegen.cmi
bytecomp/bytegen.cmx : \
bytecomp/instruct.cmx \
typing/ident.cmx \
typing/env.cmx \
+ lambda/debuginfo.cmx \
utils/config.cmx \
+ utils/clflags.cmx \
parsing/asttypes.cmi \
bytecomp/bytegen.cmi
bytecomp/bytegen.cmi : \
asmcomp/branch_relaxation_intf.cmo
asmcomp/branch_relaxation_intf.cmo : \
asmcomp/linear.cmi \
+ lambda/debuginfo.cmi \
asmcomp/cmm.cmi \
asmcomp/arch.cmo
asmcomp/branch_relaxation_intf.cmx : \
asmcomp/linear.cmx \
+ lambda/debuginfo.cmx \
asmcomp/cmm.cmx \
asmcomp/arch.cmx
asmcomp/cmm.cmo : \
asmcomp/cmm_helpers.cmi : \
utils/targetint.cmi \
typing/primitive.cmi \
- parsing/location.cmi \
lambda/lambda.cmi \
lambda/debuginfo.cmi \
file_formats/cmx_format.cmi \
asmcomp/comballoc.cmo : \
asmcomp/reg.cmi \
asmcomp/mach.cmi \
+ lambda/debuginfo.cmi \
utils/config.cmi \
asmcomp/arch.cmo \
asmcomp/comballoc.cmi
asmcomp/comballoc.cmx : \
asmcomp/reg.cmx \
asmcomp/mach.cmx \
+ lambda/debuginfo.cmx \
utils/config.cmx \
asmcomp/arch.cmx \
asmcomp/comballoc.cmi
asmcomp/x86_ast.cmi \
asmcomp/reg.cmi \
asmcomp/proc.cmi \
+ utils/numbers.cmi \
utils/misc.cmi \
asmcomp/mach.cmi \
asmcomp/linear.cmi \
lambda/lambda.cmi \
asmcomp/emitaux.cmi \
utils/domainstate.cmi \
- lambda/debuginfo.cmi \
utils/config.cmi \
middle_end/compilenv.cmi \
asmcomp/cmm.cmi \
asmcomp/x86_ast.cmi \
asmcomp/reg.cmx \
asmcomp/proc.cmx \
+ utils/numbers.cmx \
utils/misc.cmx \
asmcomp/mach.cmx \
asmcomp/linear.cmx \
lambda/lambda.cmx \
asmcomp/emitaux.cmx \
utils/domainstate.cmx \
- lambda/debuginfo.cmx \
utils/config.cmx \
middle_end/compilenv.cmx \
asmcomp/cmm.cmx \
lambda/lambda.cmi \
lambda/debuginfo.cmi \
asmcomp/cmm.cmi \
+ utils/clflags.cmi \
middle_end/backend_var.cmi \
parsing/asttypes.cmi \
asmcomp/printcmm.cmi
lambda/lambda.cmx \
lambda/debuginfo.cmx \
asmcomp/cmm.cmx \
+ utils/clflags.cmx \
middle_end/backend_var.cmx \
parsing/asttypes.cmi \
asmcomp/printcmm.cmi
asmcomp/linear.cmi \
lambda/lambda.cmi \
lambda/debuginfo.cmi \
+ utils/clflags.cmi \
asmcomp/printlinear.cmi
asmcomp/printlinear.cmx : \
asmcomp/printmach.cmx \
asmcomp/linear.cmx \
lambda/lambda.cmx \
lambda/debuginfo.cmx \
+ utils/clflags.cmx \
asmcomp/printlinear.cmi
asmcomp/printlinear.cmi : \
asmcomp/linear.cmi
lambda/debuginfo.cmi \
asmcomp/cmm.cmi \
middle_end/backend_var.cmi \
+ parsing/asttypes.cmi \
asmcomp/arch.cmo
asmcomp/selection.cmo : \
asmcomp/spacetime_profiling.cmi \
asmcomp/split.cmi : \
asmcomp/mach.cmi
asmcomp/strmatch.cmo : \
- parsing/location.cmi \
lambda/lambda.cmi \
lambda/debuginfo.cmi \
asmcomp/cmm.cmi \
asmcomp/arch.cmo \
asmcomp/strmatch.cmi
asmcomp/strmatch.cmx : \
- parsing/location.cmx \
lambda/lambda.cmx \
lambda/debuginfo.cmx \
asmcomp/cmm.cmx \
asmcomp/arch.cmx \
asmcomp/strmatch.cmi
asmcomp/strmatch.cmi : \
- parsing/location.cmi \
lambda/debuginfo.cmi \
asmcomp/cmm.cmi
asmcomp/x86_ast.cmi :
typing/path.cmi \
typing/ident.cmi \
lambda/debuginfo.cmi \
+ utils/clflags.cmi \
middle_end/backend_var.cmi
middle_end/backend_var.cmx : \
typing/path.cmx \
typing/ident.cmx \
lambda/debuginfo.cmx \
+ utils/clflags.cmx \
middle_end/backend_var.cmi
middle_end/backend_var.cmi : \
typing/path.cmi \
parsing/location.cmi \
lambda/lambda.cmi \
utils/int_replace_polymorphic_compare.cmi \
+ lambda/debuginfo.cmi \
middle_end/internal_variable_names.cmi
middle_end/internal_variable_names.cmx : \
parsing/location.cmx \
lambda/lambda.cmx \
utils/int_replace_polymorphic_compare.cmx \
+ lambda/debuginfo.cmx \
middle_end/internal_variable_names.cmi
middle_end/internal_variable_names.cmi : \
- parsing/location.cmi \
lambda/lambda.cmi
middle_end/linkage_name.cmo : \
utils/int_replace_polymorphic_compare.cmi \
lambda/debuginfo.cmo : \
parsing/location.cmi \
utils/int_replace_polymorphic_compare.cmi \
+ typing/ident.cmi \
+ parsing/asttypes.cmi \
lambda/debuginfo.cmi
lambda/debuginfo.cmx : \
parsing/location.cmx \
utils/int_replace_polymorphic_compare.cmx \
+ typing/ident.cmx \
+ parsing/asttypes.cmi \
lambda/debuginfo.cmi
lambda/debuginfo.cmi : \
- parsing/location.cmi
+ parsing/location.cmi \
+ typing/ident.cmi \
+ parsing/asttypes.cmi
lambda/lambda.cmo : \
typing/types.cmi \
typing/primitive.cmi \
typing/path.cmi \
utils/misc.cmi \
parsing/longident.cmi \
- parsing/location.cmi \
typing/ident.cmi \
typing/env.cmi \
+ lambda/debuginfo.cmi \
parsing/asttypes.cmi \
lambda/lambda.cmi
lambda/lambda.cmx : \
typing/path.cmx \
utils/misc.cmx \
parsing/longident.cmx \
- parsing/location.cmx \
typing/ident.cmx \
typing/env.cmx \
+ lambda/debuginfo.cmx \
parsing/asttypes.cmi \
lambda/lambda.cmi
lambda/lambda.cmi : \
typing/types.cmi \
typing/primitive.cmi \
typing/path.cmi \
- parsing/location.cmi \
typing/ident.cmi \
typing/env.cmi \
+ lambda/debuginfo.cmi \
parsing/asttypes.cmi
lambda/matching.cmo : \
typing/types.cmi \
lambda/lambda.cmi \
typing/ident.cmi \
typing/env.cmi \
+ lambda/debuginfo.cmi \
utils/clflags.cmi \
typing/btype.cmi \
parsing/asttypes.cmi \
lambda/lambda.cmx \
typing/ident.cmx \
typing/env.cmx \
+ lambda/debuginfo.cmx \
utils/clflags.cmx \
typing/btype.cmx \
parsing/asttypes.cmi \
typing/typedtree.cmi \
parsing/location.cmi \
lambda/lambda.cmi \
- typing/ident.cmi
+ typing/ident.cmi \
+ lambda/debuginfo.cmi
lambda/printlambda.cmo : \
typing/types.cmi \
typing/printtyp.cmi \
parsing/location.cmi \
lambda/lambda.cmi \
typing/ident.cmi \
+ lambda/debuginfo.cmi \
+ utils/clflags.cmi \
parsing/asttypes.cmi \
lambda/printlambda.cmi
lambda/printlambda.cmx : \
parsing/location.cmx \
lambda/lambda.cmx \
typing/ident.cmx \
+ lambda/debuginfo.cmx \
+ utils/clflags.cmx \
parsing/asttypes.cmi \
lambda/printlambda.cmi
lambda/printlambda.cmi : \
lambda/runtimedef.cmi :
lambda/simplif.cmo : \
utils/warnings.cmi \
- typing/stypes.cmi \
typing/primitive.cmi \
parsing/location.cmi \
lambda/lambda.cmi \
typing/ident.cmi \
+ lambda/debuginfo.cmi \
utils/clflags.cmi \
parsing/asttypes.cmi \
- typing/annot.cmi \
lambda/simplif.cmi
lambda/simplif.cmx : \
utils/warnings.cmx \
- typing/stypes.cmx \
typing/primitive.cmx \
parsing/location.cmx \
lambda/lambda.cmx \
typing/ident.cmx \
+ lambda/debuginfo.cmx \
utils/clflags.cmx \
parsing/asttypes.cmi \
- typing/annot.cmi \
lambda/simplif.cmi
lambda/simplif.cmi : \
- parsing/location.cmi \
lambda/lambda.cmi \
typing/ident.cmi
lambda/switch.cmo : \
- parsing/location.cmi \
lambda/switch.cmi
lambda/switch.cmx : \
- parsing/location.cmx \
lambda/switch.cmi
-lambda/switch.cmi : \
- parsing/location.cmi
+lambda/switch.cmi :
lambda/translattribute.cmo : \
utils/warnings.cmi \
typing/typedtree.cmi \
lambda/lambda.cmi \
typing/ident.cmi \
typing/env.cmi \
+ lambda/debuginfo.cmi \
utils/clflags.cmi \
typing/btype.cmi \
parsing/asttypes.cmi \
lambda/lambda.cmx \
typing/ident.cmx \
typing/env.cmx \
+ lambda/debuginfo.cmx \
utils/clflags.cmx \
typing/btype.cmx \
parsing/asttypes.cmi \
parsing/location.cmi \
lambda/lambda.cmi \
typing/ident.cmi \
+ lambda/debuginfo.cmi \
parsing/asttypes.cmi
lambda/translcore.cmo : \
typing/types.cmi \
lambda/lambda.cmi \
typing/ident.cmi \
typing/env.cmi \
+ lambda/debuginfo.cmi \
utils/config.cmi \
utils/clflags.cmi \
typing/btype.cmi \
lambda/lambda.cmx \
typing/ident.cmx \
typing/env.cmx \
+ lambda/debuginfo.cmx \
utils/config.cmx \
utils/clflags.cmx \
typing/btype.cmx \
lambda/lambda.cmi \
typing/ident.cmi \
typing/env.cmi \
+ lambda/debuginfo.cmi \
parsing/asttypes.cmi
lambda/translmod.cmo : \
typing/types.cmi \
lambda/lambda.cmi \
typing/ident.cmi \
typing/env.cmi \
+ lambda/debuginfo.cmi \
typing/ctype.cmi \
utils/clflags.cmi \
parsing/asttypes.cmi \
lambda/lambda.cmx \
typing/ident.cmx \
typing/env.cmx \
+ lambda/debuginfo.cmx \
typing/ctype.cmx \
utils/clflags.cmx \
parsing/asttypes.cmi \
lambda/translobj.cmo : \
typing/primitive.cmi \
utils/misc.cmi \
- parsing/location.cmi \
lambda/lambda.cmi \
typing/ident.cmi \
typing/env.cmi \
lambda/translobj.cmx : \
typing/primitive.cmx \
utils/misc.cmx \
- parsing/location.cmx \
lambda/lambda.cmx \
typing/ident.cmx \
typing/env.cmx \
lambda/lambda.cmi \
typing/ident.cmi \
typing/env.cmi \
+ lambda/debuginfo.cmi \
utils/config.cmi \
utils/clflags.cmi \
parsing/asttypes.cmi \
lambda/lambda.cmx \
typing/ident.cmx \
typing/env.cmx \
+ lambda/debuginfo.cmx \
utils/config.cmx \
utils/clflags.cmx \
parsing/asttypes.cmi \
utils/numbers.cmi \
middle_end/flambda/base_types/mutable_variable.cmi \
utils/misc.cmi \
- parsing/location.cmi \
lambda/lambda.cmi \
utils/int_replace_polymorphic_compare.cmi \
typing/ident.cmi \
utils/numbers.cmx \
middle_end/flambda/base_types/mutable_variable.cmx \
utils/misc.cmx \
- parsing/location.cmx \
lambda/lambda.cmx \
utils/int_replace_polymorphic_compare.cmx \
typing/ident.cmx \
middle_end/symbol.cmi \
middle_end/flambda/base_types/static_exception.cmi \
middle_end/flambda/base_types/mutable_variable.cmi \
- parsing/location.cmi \
lambda/lambda.cmi \
typing/ident.cmi
middle_end/flambda/closure_offsets.cmo : \
typing/typemod.cmi \
typing/typedtree.cmi \
typing/typecore.cmi \
- typing/stypes.cmi \
utils/profile.cmi \
typing/printtyped.cmi \
typing/printtyp.cmi \
typing/typemod.cmx \
typing/typedtree.cmx \
typing/typecore.cmx \
- typing/stypes.cmx \
utils/profile.cmx \
typing/printtyped.cmx \
typing/printtyp.cmx \
typing/env.cmi
driver/compmisc.cmo : \
utils/warnings.cmi \
+ typing/types.cmi \
typing/typemod.cmi \
utils/misc.cmi \
parsing/location.cmi \
driver/compmisc.cmi
driver/compmisc.cmx : \
utils/warnings.cmx \
+ typing/types.cmx \
typing/typemod.cmx \
utils/misc.cmx \
parsing/location.cmx \
parsing/parser.cmi \
parsing/parse.cmi \
utils/misc.cmi \
- parsing/longident.cmi \
parsing/location.cmi \
parsing/lexer.cmi \
parsing/depend.cmi \
parsing/parser.cmx \
parsing/parse.cmx \
utils/misc.cmx \
- parsing/longident.cmx \
parsing/location.cmx \
parsing/lexer.cmx \
parsing/depend.cmx \
bytecomp/bytesections.cmx
toplevel/genprintval.cmo : \
typing/types.cmi \
+ parsing/syntaxerr.cmi \
typing/printtyp.cmi \
typing/predef.cmi \
typing/path.cmi \
+ parsing/parse.cmi \
typing/outcometree.cmi \
typing/oprint.cmi \
utils/misc.cmi \
parsing/longident.cmi \
+ parsing/lexer.cmi \
typing/ident.cmi \
typing/env.cmi \
typing/datarepr.cmi \
toplevel/genprintval.cmi
toplevel/genprintval.cmx : \
typing/types.cmx \
+ parsing/syntaxerr.cmx \
typing/printtyp.cmx \
typing/predef.cmx \
typing/path.cmx \
+ parsing/parse.cmx \
typing/outcometree.cmi \
typing/oprint.cmx \
utils/misc.cmx \
parsing/longident.cmx \
+ parsing/lexer.cmx \
typing/ident.cmx \
typing/env.cmx \
typing/datarepr.cmx \
# Expect tests with overly long lines of expected output
testsuite/tests/parsing/docstrings.ml typo.very-long-line
-tools/magic typo.missing-header
+tools/magic typo.missing-header
+tools/eventlog_metadata.in typo.missing-header
# TODO we should fix the long-line errors in yacc/*.c
/yacc/*.[ch] typo.very-long-line=may
/tools/ci/appveyor/appveyor_build.cmd text eol=crlf
configure.ac text eol=lf
-autogen text eol=lf
build-aux/compile text eol=lf
build-aux/config.guess text eol=lf
build-aux/config.sub text eol=lf
build-aux/missing text eol=lf
ocamldoc/remove_DEBUG text eol=lf
ocamltest/getocamloptdefaultflags text eol=lf
+ocamltest/ocamltest.org typo.long-line=may typo.missing-header
stdlib/Compflags text eol=lf
stdlib/sharpbang text eol=lf
+tools/autogen text eol=lf
tools/ci/inria/remove-sinh-primitive.patch text eol=lf
tools/check-typo text eol=lf
tools/ci-build text eol=lf
/bytecomp/opcodes.ml
/bytecomp/opcodes.mli
-/debugger/lexer.ml
-/debugger/parser.ml
-/debugger/parser.mli
+/debugger/debugger_lexer.ml
+/debugger/debugger_parser.ml
+/debugger/debugger_parser.mli
/debugger/ocamldebug
/emacs/ocamltags
/ocamltest/tsl_lexer.ml
/ocamltest/tsl_parser.ml
/ocamltest/tsl_parser.mli
+/ocamltest/ocamltest.html
/otherlibs/dynlink/extract_crc
/otherlibs/dynlink/dynlink_platform_intf.mli
/tools/make_opcodes
/tools/make_opcodes.ml
/tools/caml-tex
+/tools/eventlog_metadata
/utils/config.ml
/utils/domainstate.ml
#**************************************************************************
dist: xenial
-sudo: false
language: c
git:
submodules: false
A bootstrap is required for example when something changes in the
runtime system (the magic number of bytecode executables, the format of
bytecode instructions, the set of available primitives) or when the
-format of .cmi files is modified. In particular, given that the .cmi
-files contain information related to types, modifying the way a type is
-represented will modify the format of .cmi files and thus require a
-bootstrap.
+format of OCaml compilation object files like .cmi files is modified. In
+particular, given that the .cmi files contain information related to
+types, modifying the way a type is represented will modify the format
+of .cmi files and thus require a bootstrap.
Here is how to perform a change that requires a bootstrap:
If you notice that this procedure fails for a given change you are
trying to implement, please report it so that the procedure can be
updated to also cope with your change.
+
+If you want to upstream your changes, indicate in the message of the
+commit that the changes need a bootstrap. Perform the bootstrap and
+commit the result of the bootstrap separately, after that commit.
-OCaml 4.10.1 (20 August 2020)
+OCaml 4.11.0 (19 August 2020)
+---------------------------
+
+(Changes that can break existing programs are marked with a "*")
+
+### Runtime system:
+
+- #9096: Print function names in backtraces.
+ Old output:
+ > Called from file "foo.ml", line 16, characters 42-53
+ New output:
+ > Called from Foo.bar in file "foo.ml", line 16, characters 42-53
+ (Stephen Dolan, review by Leo White and Mark Shinwell)
+
+- #9082: The instrumented runtime now records logs in the CTF format.
+ A new API is available in the runtime to collect runtime statistics,
+ replacing the previous instrumented runtime macros.
+ Gc.eventlog_pause and Gc.eventlog_resume were added to allow user to control
+ instrumentation in a running program.
+ See the manual for more information on how to use this instrumentation mode.
+ (Enguerrand Decorne and Stephen Dolan, with help and review from
+ David Allsopp, Sébastien Hinderer, review by Anil Madhavapeddy,
+ Nicolás Ojeda Bär, Shakthi Kannan, KC Sivaramakrishnan, Gabriel Scherer,
+ Guillaume Munch-Maccagnoni, Damien Doligez, Leo White, Daniel Bünzli
+ and Xavier Leroy)
+
+- #9230, #9362: Memprof support for native allocations.
+ (Jacques-Henri Jourdan and Stephen Dolan, review by Gabriel Scherer)
+
+- #8920, #9238, #9239, #9254, #9458: New API for statistical memory profiling
+ in Memprof.Gc. The new version does no longer use ephemerons and allows
+ registering callbacks for promotion and deallocation of memory
+ blocks.
+ The new API no longer gives the block tags to the allocation callback.
+ (Stephen Dolan and Jacques-Henri Jourdan, review by Damien Doligez
+ and Gabriel Scherer)
+
+- #9353: Reimplement `output_value` and the `Marshal.to_*` functions
+ using a hash table to detect sharing, instead of temporary in-place
+ modifications. This is a prerequisite for Multicore OCaml.
+ (Xavier Leroy and Basile Clément, review by Gabriel Scherer and
+ Stephen Dolan)
+
+
+- #9119: Make [caml_stat_resize_noexc] compatible with the [realloc]
+ API when the old block is NULL.
+ (Jacques-Henri Jourdan, review by Xavier Leroy)
+
+- #9233: Restore the bytecode stack after an allocation.
+ (Stephen Dolan, review by Gabriel Scherer and Jacques-Henri Jourdan)
+
+- #9249: restore definition of ARCH_ALIGN_INT64 in m.h if the architecture
+ requires 64-bit integers to be double-word aligned (autoconf regression)
+ (David Allsopp, review by Sébastien Hinderer)
+
+- #9259: Made `Ephemeron.blit_key` and `Weak.blit` faster. They are now
+ linear in the size of the range being copied instead of depending on the
+ total sizes of the ephemerons or weak arrays involved.
+ (Arseniy Alekseyev, design advice by Leo White, review by François Bobot
+ and Damien Doligez)
+
+- #9279: Memprof optimisation.
+ (Stephen Dolan, review by Jacques-Henri Jourdan)
+
+- #9280: Micro-optimise allocations on amd64 to save a register.
+ (Stephen Dolan, review by Xavier Leroy)
+
+- #9426: build the Mingw ports with higher levels of GCC optimization
+ (Xavier Leroy, review by Sébastien Hinderer)
+
+* #9483: Remove accidental inclusion of <stdio.h> in <caml/misc.h>
+ The only release with the inclusion of stdio.h has been 4.10.0
+ (Christopher Zimmermann, review by Xavier Leroy and David Allsopp)
+
+- #9282: Make Cconst_symbol have typ_int to fix no-naked-pointers mode.
+ (Stephen Dolan, review by Mark Shinwell, Xavier Leroy and Vincent Laviron)
+
+- #9497: Harmonise behaviour between bytecode and native code for
+ recursive module initialisation in one particular case (fixes #9494).
+ (Mark Shinwell, David Allsopp, Vincent Laviron, Xavier Leroy,
+ Geoff Reedy, original bug report by Arlen Cox)
+
+- #8791: use a variable-length encoding when marshalling bigarray dimensions,
+ avoiding overflow.
+ (Jeremy Yallop, Stephen Dolan, review by Xavier Leroy)
+
+### Code generation and optimizations:
+
+- #9441: Add RISC-V RV64G native-code backend.
+ (Nicolás Ojeda Bär, review by Xavier Leroy and Gabriel Scherer)
+
+- #9316, #9443, #9463, #9782: Use typing information from Clambda
+ for mutable Cmm variables.
+ (Stephen Dolan, review by Vincent Laviron, Guillaume Bury, Xavier Leroy,
+ and Gabriel Scherer; temporary bug report by Richard Jones)
+
+- #8637, #8805, #9247, #9296: Record debug info for each allocation.
+ (Stephen Dolan and Jacques-Henri Jourdan, review by Damien Doligez,
+ KC Sivaramakrishnan and Xavier Leroy)
+
+
+- #9193: Make tuple matching optimisation apply to Lswitch and Lstringswitch.
+ (Stephen Dolan, review by Thomas Refis and Gabriel Scherer)
+
+- #9392: Visit registers at most once in Coloring.iter_preferred.
+ (Stephen Dolan, review by Pierre Chambart and Xavier Leroy)
+
+- #9549, #9557: Make -flarge-toc the default for PowerPC and introduce
+ -fsmall-toc to enable the previous behaviour.
+ (David Allsopp, report by Nathaniel Wesley Filardo, review by Xavier Leroy)
+
+### Language features
+
+- #8820, #9166: quoted extensions: {%foo|...|} is lighter syntax for
+ [%foo {||}], and {%foo bar|...|bar} for [%foo {bar|...|bar}].
+ (Gabriel Radanne, Leo White, Gabriel Scherer and Pieter Goetschalckx,
+ request by Bikal Lem)
+
+- #7364, #2188, #9592, #9609: improvement of the unboxability check for types
+ with a single constructor. Mutually-recursive type declarations can
+ now contain unboxed types. This is based on the paper
+ https://arxiv.org/abs/1811.02300
+ (Gabriel Scherer and Rodolphe Lepigre,
+ review by Jeremy Yallop, Damien Doligez and Frédéric Bour)
+
+- #1154, #1706: spellchecker hints and type-directed disambiguation
+ for extensible sum type constructors
+ (Florian Angeletti, review by Alain Frisch, Gabriel Radanne, Gabriel Scherer
+ and Leo White)
+
+
+- #6673, #1132, #9617: Relax the handling of explicit polymorphic types.
+ This improves error messages in some polymorphic recursive definition,
+ and requires less polymorphic annotations in some cases of
+ mutually-recursive definitions involving polymorphic recursion.
+ (Leo White, review by Jacques Garrigue and Gabriel Scherer)
+
+- #9232: allow any class type paths in #-types,
+ For instance, "val f: #F(X).t -> unit" is now allowed.
+ (Florian Angeletti, review by Gabriel Scherer, suggestion by Leo White)
+
+### Standard library:
+
+- #9077: Add Seq.cons and Seq.append
+ (Sébastien Briais, review by Yawar Amin and Florian Angeletti)
+
+- #9235: Add Array.exists2 and Array.for_all2
+ (Bernhard Schommer, review by Armaël Guéneau)
+
+- #9226: Add Seq.unfold.
+ (Jeremy Yallop, review by Hezekiah M. Carty, Gabriel Scherer and
+ Gabriel Radanne)
+
+- #9059: Added List.filteri function, same as List.filter but
+ with the index of the element.
+ (Léo Andrès, review by Alain Frisch)
+
+- #8894: Added List.fold_left_map function combining map and fold.
+ (Bernhard Schommer, review by Alain Frisch and github user @cfcs)
+
+- #9365: Set.filter_map and Map.filter_map
+ (Gabriel Scherer, review by Stephen Dolan and Nicolás Ojeda Bär)
+
+
+- #9248: Add Printexc.default_uncaught_exception_handler
+ (Raphael Sousa Santos, review by Daniel Bünzli)
+
+- #8771: Lexing: add set_position and set_filename to change (fake)
+ the initial tracking position of the lexbuf.
+ (Konstantin Romanov, Miguel Lumapat, review by Gabriel Scherer,
+ Sébastien Hinderer, and David Allsopp)
+
+- #9237: `Format.pp_update_geometry ppf (fun geo -> {geo with ...})`
+ for formatter geometry changes that are robust to new geometry fields.
+ (Gabriel Scherer, review by Josh Berdine and Florian Angeletti)
+
+- #7110: Added Printf.ikbprintf and Printf.ibprintf
+ (Muskan Garg, review by Gabriel Scherer and Florian Angeletti)
+
+- #9266: Install pretty-printer for the exception Fun.Finally_raised.
+ (Guillaume Munch-Maccagnoni, review by Daniel Bünzli, Gabriel Radanne,
+ and Gabriel Scherer)
+
+### Other libraries:
+
+- #9106: Register printer for Unix_error in win32unix, as in unix.
+ (Christopher Zimmermann, review by David Allsopp)
+
+- #9183: Preserve exception backtrace of exceptions raised by top-level phrases
+ of dynlinked modules.
+ (Nicolás Ojeda Bär, review by Xavier Clerc and Gabriel Scherer)
+
+- #9320, #9550: under Windows, make sure that the Unix.exec* functions
+ properly quote their argument lists.
+ (Xavier Leroy, report by André Maroneze, review by Nicolás Ojeda Bär
+ and David Allsopp)
+
+- #9490, #9505: ensure proper rounding of file times returned by
+ Unix.stat, Unix.lstat, Unix.fstat.
+ (Xavier Leroy and Guillaume Melquiond, report by David Brown,
+ review by Gabriel Scherer and David Allsopp)
+
+### Tools:
+
+- #9283, #9455, #9457: add a new toplevel directive `#use_output "<command>"` to
+ run a command and evaluate its output.
+ (Jérémie Dimino, review by David Allsopp)
+
+
+- #6969: Argument -nocwd added to ocamldep
+ (Muskan Garg, review by Florian Angeletti)
+
+- #8676, #9594: turn debugger off in programs launched by the program
+ being debugged
+ (Xavier Leroy, report by Michael Soegtrop, review by Gabriel Scherer)
+
+- #9057: aid debugging the debugger by preserving backtraces of unhandled
+ exceptions.
+ (David Allsopp, review by Gabriel Scherer)
+
+- #9276: objinfo: cm[x]a print extra C options, objects and dlls in
+ the order given on the cli. Follow up to #4949.
+ (Daniel Bünzli, review by Gabriel Scherer)
+
+- #463: objinfo: better errors on object files coming
+ from a different (older or newer), incompatible compiler version.
+ (Gabriel Scherer, review by Gabriel Radanne and Damien Doligez)
+
+- #9181: make objinfo work on Cygwin and look for the caml_plugin_header
+ symbol in both the static and the dynamic symbol tables.
+ (Sébastien Hinderer, review by Gabriel Scherer and David Allsopp)
+
+* #9197: remove compatibility logic from #244 that was designed to
+ synchronize toplevel printing margins with Format.std_formatter,
+ but also resulted in unpredictable/fragile changes to formatter
+ margins.
+ Setting the margins on the desired formatters should now work.
+ typically on `Format.std_formatter`.
+ Note that there currently is no robust way to do this from the
+ toplevel, as applications may redirect toplevel printing. In
+ a compiler/toplevel driver, one should instead access
+ `Location.formatter_for_warnings`; it is not currently exposed
+ to the toplevel.
+ (Gabriel Scherer, review by Armaël Guéneau)
+
+- #9207, #9210: fix ocamlyacc to work correctly with up to 255 entry
+ points to the grammar.
+ (Andreas Abel, review by Xavier Leroy)
+
+- #9482, #9492: use diversions (@file) to work around OS limitations
+ on length of Sys.command argument.
+ (Xavier Leroy, report by Jérémie Dimino, review by David Allsopp)
+
+- #9552: restore ocamloptp build and installation
+ (Florian Angeletti, review by David Allsopp and Xavier Leroy)
+
+### Manual and documentation:
+
+- #9141: beginning of the ocamltest reference manual
+ (Sébastien Hinderer, review by Gabriel Scherer and Thomas Refis)
+
+- #9228: Various Map documentation improvements: add missing key argument in
+ the 'merge' example; clarify the relationship between input and output keys
+ in 'union'; note that find and find_opt return values, not bindings.
+ (Jeremy Yallop, review by Gabriel Scherer and Florian Angeletti)
+
+- #9255, #9300: reference chapter, split the expression grammar
+ (Florian Angeletti, report by Harrison Ainsworth, review by Gabriel Scherer)
+
+- #9325: documented base case for `List.for_all` and `List.exists`
+ (Glenn Slotte, review by Florian Angeletti)
+
+- #9410, #9422: replaced naive fibonacci example with gcd
+ (Anukriti Kumar, review by San Vu Ngoc, Florian Angeletti, Léo Andrès)
+
+- #9541: Add a documentation page for the instrumented runtime;
+ additional changes to option names in the instrumented runtime.
+ (Enguerrand Decorne, review by Anil Madhavapeddy, Gabriel Scherer,
+ Daniel Bünzli, David Allsopp, Florian Angeletti,
+ and Sébastien Hinderer)
+
+- #9610: manual, C FFI: naked pointers are deprecated, detail the
+ forward-compatible options for handling out-of-heap pointers.
+ (Xavier Leroy, review by Mark Shinwell, David Allsopp and Florian Angeletti)
+
+- #9618: clarify the Format documentation on the margin and maximum indentation
+ limit
+ (Florian Angeletti, review by Josh Berdine)
+
+
+- #8644: fix formatting comment about @raise in stdlib's mli files
+ (Élie Brami, review by David Allsopp)
+
+- #9327, #9401: manual, fix infix attribute examples
+ (Florian Angeletti, report by David Cadé, review by Gabriel Scherer)
+
+- #9403: added a description for warning 67 and added a "." at the end of
+ warnings for consistency.
+ (Muskan Garg, review by Gabriel Scherer and Florian Angeletti)
+
+- #7708, #9580: Ensure Stdlib documentation index refers to Stdlib.
+ (Stephen Dolan, review by Florian Angeletti, report by Hannes Mehnert)
+
+### Compiler user-interface and warnings:
+
+- #9712: Update the version format to allow "~".
+ The new format is "major.minor[.patchlevel][(+|~)additional-info]",
+ for instance "4.12.0~beta1+flambda".
+ This is a documentation-only change for the 4.11 branch, the new format
+ will be used starting with the 4.12 branch.
+ (Florian Angeletti, review by Damien Doligez and Xavier Leroy)
+
+- #1664: make -output-complete-obj link the runtime native c libraries when
+ building shared libraries like `-output-obj`.
+ (Florian Angeletti, review by Nicolás Ojeda Bär)
+
+- #9349: Support [@inlined hint] attribute.
+ (Leo White, review by Stephen Dolan)
+
+- #2141: generate .annot files from cmt data; deprecate -annot.
+ (Nicolás Ojeda Bär, review by Alain Frisch, Gabriel Scherer and Damien
+ Doligez)
+
+
+* #7678, #8631: ocamlc -c and ocamlopt -c pass same switches to the C
+ compiler when compiling .c files (in particular, this means ocamlopt
+ passes -fPIC on systems requiring it for shared library support).
+ (David Allsopp, report by Daniel Bünzli, review by Sébastien Hinderer)
+
+- #9074: reworded error message for non-regular structural types
+ (Florian Angeletti, review by Jacques Garrigue and Leo White,
+ report by Chas Emerick)
+
+- #8938: Extend ocamlopt option "-stop-after" to handle "scheduling" argument.
+ (Greta Yorsh, review by Florian Angeletti and Sébastien Hinderer)
+
+- #8945, #9086: Fix toplevel show directive to work with constructors
+ (Simon Parry, review by Gabriel Scherer, Jeremy Yallop,
+ Alain Frisch, Florian Angeletti)
+
+- #9107: improved error message for exceptions in module signature errors
+ (Gabriel Scherer, review by Florian Angeletti)
+
+- #9208: -dno-locations option to hide source locations (and debug events)
+ from intermediate-representation dumps (-dfoo).
+ (Gabriel Scherer, review by Vincent Laviron)
+
+- #9393: Improve recursive module usage warnings
+ (Leo White, review by Thomas Refis)
+
+- #9486: Fix configuration for the Haiku operating system
+ (Sylvain Kerjean, review by David Allsopp and Sébastien Hinderer)
+
+### Internal/compiler-libs changes:
+
+- #9021: expose compiler Longident.t parsers
+ (Florian Angeletti, review by Gabriel Scherer)
+
+- #9452: Add locations to docstring attributes
+ (Leo White, review by Gabriel Scherer)
+
+
+- #463: a new Misc.Magic_number module for user-friendly parsing
+ and validation of OCaml magic numbers.
+ (Gabriel Scherer, review by Gabriel Radanne and Damien Doligez)
+
+- #1176: encourage better compatibility with older Microsoft C compilers by
+ using GCC's -Wdeclaration-after-statement when available. Introduce
+ Caml_inline to stop abuse of the inline keyword on MSVC and to help ensure
+ that only static inline is used in the codebase (erroneous instance in
+ runtime/win32.c removed).
+ (David Allsopp, review by Oliver Andrieu and Xavier Leroy)
+
+- #8934: Stop relying on location to track usage
+ (Thomas Refis, review by Gabriel Radanne)
+
+- #8970: separate value patterns (matching on values) from computation patterns
+ (matching on the effects of a copmutation) in the typedtree.
+ (Gabriel Scherer, review by Jacques Garrigue and Alain Frisch)
+
+- #9060: ensure that Misc.protect_refs preserves backtraces
+ (Gabriel Scherer, review by Guillaume Munch-Maccagnoni and David Allsopp)
+
+- #9078: make all compilerlibs/ available to ocamltest.
+ (Gabriel Scherer, review by Sébastien Hinderer)
+
+- #9079: typecore/parmatch: refactor ppat_of_type and refine
+ the use of backtracking on wildcard patterns
+ (Florian Angeletti, Jacques Garrigue, Gabriel Scherer,
+ review by Thomas Refis)
+
+- #9081: typedtree, make the pat_env field of pattern data immutable
+ (Gabriel Scherer, review by Jacques Garrigue, report by Alain Frisch)
+
+- #9178, #9182, #9196: refactor label-disambiguation (Typecore.NameChoice)
+ (Gabriel Scherer, Thomas Refis, Florian Angeletti and Jacques Garrigue,
+ reviewing each other without self-loops)
+
+- #9321, #9322, #9359, #9361, #9417, #9447: refactor the
+ pattern-matching compiler
+ (Thomas Refis and Gabriel Scherer, review by Florian Angeletti)
+
+- #9211, #9215, #9222: fix Makefile dependencies in
+ compilerlibs, dynlink, ocamltest.
+ (Gabriel Scherer, review by Vincent Laviron and David Allsopp)
+
+- #9305: Avoid polymorphic compare in Ident
+ (Leo White, review by Xavier Leroy and Gabriel Scherer)
+
+- #7927: refactor val_env met_env par_env to class_env
+ (Muskan Garg, review by Gabriel Scherer and Florian Angeletti)
+
+- #2324, #9613: Replace the caml_int_compare and caml_float_compare
+ (C functions) with primitives.
+ (Greta Yorsh, review by Stephen Dolan and Vincent Laviron)
+
+- #9246: Avoid rechecking functor applications
+ (Leo White, review by Jacques Garrigue)
+
+- #9402: Remove `sudo:false` from .travis.yml
+ (Hikaru Yoshimura)
+
+* #9411: forbid optional arguments reordering with -nolabels
+ (Thomas Refis, review by Frédéric Bour and Jacques Garrigue)
+
+- #9414: testsuite, ocamltest: keep test artifacts only on failure.
+ Use KEEP_TEST_DIR_ON_SUCCESS=1 to keep all artifacts.
+ (Gabriel Scherer, review by Sébastien Hinderer)
+
+
+### Build system:
+
+- #9250: Add --disable-ocamltest to configure and disable building for
+ non-development builds.
+ (David Allsopp, review by Sébastien Hinderer)
+
+### Bug fixes:
+
+- #7520, #9547: Odd behaviour of refutation cases with polymorphic variants
+ (Jacques Garrigue, report by Leo White, reviews by Gabriel Scherer and Leo)
+
+- #7562, #9456: ocamlopt-generated code crashed on Alpine Linux on
+ ppc64le, arm, and i386. Fixed by turning PIE off for musl-based Linux
+ systems except amd64 (x86_64) and s390x.
+ (Xavier Leroy, review by Gabriel Scherer)
+
+- #7683, #1499: Fixes one case where the evaluation order in native-code
+ may not match the one in bytecode.
+ (Nicolás Ojeda Bär, report by Pierre Chambart, review by Gabriel Scherer)
+
+- #7696, #6608: Record expression deleted when all fields specified
+ (Jacques Garrigue, report by Jeremy Yallop)
+
+- #7741, #9645: Failure to report escaping type variable
+ (Jacques Garrigue, report by Gabriel Radanne, review by Gabriel Scherer)
+
+- #7817, #9546: Unsound inclusion check for polymorphic variant
+ (Jacques Garrigue, report by Mikhail Mandrykin, review by Gabriel Scherer)
+
+- #7897, #9537: Fix warning 38 for rebound extension constructors
+ (Leo White, review by Florian Angeletti)
+
+- #7917, #9426: Use GCC option -fexcess-precision=standard when available,
+ avoiding a problem with x87 excess precision in Float.round.
+ (Xavier Leroy, review by Sébastien Hinderer)
+
+- #9011: Allow linking .cmxa files with no units on MSVC by not requiring the
+ .lib file to be present.
+ (David Allsopp, report by Dimitry Bely, review by Xavier Leroy)
+
+- #9064: Relax the level handling when unifying row fields
+ (Leo White, review by Jacques Garrigue)
+
+- #9097: Do not emit references to dead labels introduced by #2321 (spacetime).
+ (Greta Yorsh, review by Mark Shinwell)
+
+- #9163: Treat loops properly in un_anf
+ (Leo White, review by Mark Shinwell, Pierre Chambart and Vincent Laviron)
+
+- #9189, #9281: fix a conflict with Gentoo build system
+ by removing an one-letter Makefile variable.
+ (Florian Angeletti, report by Ralph Seichter, review by David Allsopp
+ and Damien Doligez)
+
+- #9225: Do not drop bytecode debug info after C calls.
+ (Stephen Dolan, review by Gabriel Scherer and Jacques-Henri Jourdan)
+
+- #9231: Make sure a debug event (and the corresponding debug
+ information) is inserted after every primitive that can appear in a
+ collected call stack, and make sure ocamlc preserves such events
+ even if they are at tail position.
+ (Jacques-Henri Jourdan, review by Gabriel Scherer)
+
+- #9244: Fix some missing usage warnings
+ (Leo White, review by Florian Angeletti)
+
+- #9274, avoid reading cmi file while printing types
+ (Florian Angeletti, review by Gabriel Scherer)
+
+- #9307, #9345: reproducible env summaries for reproducible compilation
+ (Florian Angeletti, review by Leo White)
+
+- #9309, #9318: Fix exhaustivity checking with empty types
+ (Florian Angeletti, Stefan Muenzel and Thomas Refis, review by Gabriel Scherer
+ and Thomas Refis)
+
+- #9335: actually have --disable-stdlib-manpages not build the manpages
+ (implementation conflicted with #8837 which wasn't picked up in review)
+ (David Allsopp, review by Florian Angeletti and Sébastien Hinderer)
+
+- #9343: Re-enable `-short-paths` for some error messages
+ (Leo White, review by Florian Angeletti)
+
+- #9355, #9356: ocamldebug, fix a fatal error when printing values
+ whose type involves a functor application.
+ (Florian Angeletti, review by Gabriel Scherer, report by Cyril Six)
+
+- #9367: Make bytecode and native-code backtraces agree.
+ (Stephen Dolan, review by Gabriel Scherer)
+
+- #9375, #9477: add forgotten substitution when compiling anonymous modules
+ (Thomas Refis, review by Frédéric Bour, report by Andreas Hauptmann)
+
+- #9384, #9385: Fix copy scope bugs in substitutions
+ (Leo White, review by Thomas Refis, report by Nick Roberts)
+
+* #9388: Prohibit signature local types with constraints
+ (Leo White, review by Jacques Garrigue)
+
+- #9406, #9409: fix an error with packed module types from missing
+ cmis.
+ (Florian Angeletti, report by Thomas Leonard, review by Gabriel Radanne
+ and Gabriel Scherer)
+
+- #9415: Treat `open struct` as `include struct` in toplevel
+ (Leo White, review by Thomas Refis)
+
+- #9416: Avoid warning 58 in flambda ocamlnat
+ (Leo White, review by Florian Angeletti)
+
+- #9420: Fix memory leak when `caml_output_value_to_block` raises an exception
+ (Xavier Leroy, review by Guillaume Munch-Maccagnoni)
+
+- #9428: Fix truncated exception backtrace for C->OCaml callbacks
+ on Power and Z System
+ (Xavier Leroy, review by Nicolás Ojeda Bär)
+
+- #9623, #9642: fix typing environments in Typedecl.transl_with_constraint
+ (Gabriel Scherer, review by Jacques Garrigue and Leo White,
+ report by Hugo Heuzard)
+
+- #9695, #9702: no error when opening an alias to a missing module
+ (Jacques Garrigue, report and review by Gabriel Scherer)
+
+- #9714, #9724: Add a terminator to the `caml_domain_state` structure
+ to better ensure that members are correctly spaced.
+ (Antonin Décimo, review by David Allsopp and Xavier Leroy)
+
+OCaml 4.10 maintenance branch
-----------------------------
### Runtime system:
output channels would not be flushed).
(Nicolás Ojeda Bär, review by David Allsopp)
-- #9714, #9724: Use the C++ alignas keyword when compiling in C++ in MSVC.
- Fixes a bug with MSVC C++ 2015 onwards.
+- #9714, #9724: Use the C++ alignas keyword when compiling in C++.
+ Fixes a bug with MSVC C++ 2015/2017. Add a terminator to the
+ `caml_domain_state` structure to better ensure that members are
+ correctly spaced.
(Antonin Décimo, review by David Allsopp and Xavier Leroy)
- #9736, #9749: Compaction must start in a heap where all free blocks are
blue, which was not the case with the best-fit allocator.
(Damien Doligez, report and review by Leo White)
-### Tools:
-
-- #9552: restore ocamloptp build and installation
- (Florian Angeletti, review by David Allsopp and Xavier Leroy)
-
OCaml 4.10.0 (21 February 2020)
-------------------------------
- #9127, #9130: ocamldoc: fix the formatting of closing brace in record types.
(David Allsopp, report by San Vu Ngoc)
-- #9181: make objinfo work on Cygwin and look for the caml_plugin_header
- symbol in both the static and the dynamic symbol tables.
- (Sébastien Hinderer, review by Gabriel Scherer and David Allsopp)
-
### Build system:
- #8840: use ocaml{c,opt}.opt when available to build internal tools
- #9261: Fix a soundness bug in Rec_check, new in 4.10 (from #8908)
(Vincent Laviron, review by Jeremy Yallop and Gabriel Scherer)
-OCaml 4.09 maintenance branch:
-------------------------------
+- #9389: returns exit_code for better user response on linking_error
+ (Anukriti Kumar, review by Gabriel Scherer and sliquister)
+
+OCaml 4.09 maintenance branch
+-----------------------------
### Build system:
- #9383: Don't assume that AWKPATH includes .
(David Allsopp, report by Ian Zimmerman)
-OCaml 4.09.1 (16 Mars 2020):
-----------------------------
+OCaml 4.09.1 (16 Mars 2020)
+---------------------------
- #8855, #8858: Links for tools not created when installing with
--disable-installing-byecode-programs (e.g. ocamldep.opt installed, but
- #9050, #9076: install missing compilerlibs/ocamlmiddleend archives
(Gabriel Scherer, review by Florian Angeletti, report by Olaf Hering)
+- #9144, #9180: multiple definitions of global variables in the C runtime,
+ causing problems with GCC 10.0 and possibly with other C compilers
+ (Xavier Leroy, report by Jürgen Reuter, review by Mark Shinwell)
+
- #9180: pass -fno-common option to C compiler when available,
so as to detect problematic multiple definitions of global variables
in the C runtime
(Xavier Leroy, review by Mark Shinwell)
-- #9144, #9180: multiple definitions of global variables in the C runtime,
- causing problems with GCC 10.0 and possibly with other C compilers
- (Xavier Leroy, report by Jürgen Reuter, review by Mark Shinwell)
-
- #9128: Fix a bug in bytecode mode which could lead to a segmentation
fault. The bug was caused by the fact that the atom table shared a
page with some bytecode. The fix makes sure both the atom table and
(Jacques-Henri Jourdan, review by Stephen Dolan, Xavier Leroy and
Gabriel Scherer)
-OCaml 4.09.0 (19 September 2019):
----------------------------------
+OCaml 4.09.0 (19 September 2019)
+--------------------------------
### Runtime system:
- #8515: manual, precise constraints on reexported types
(Florian Angeletti, review by Gabriel Scherer)
+- #9327, #9401: manual, fix infix attribute examples
+ (Florian Angeletti, report by David Cadé, review by Gabriel Scherer)
+
### Tools:
- #2221: ocamldep will now correctly allow a .ml file in an include directory
(Thomas Refis, review by David Allsopp, Florian Angeletti, Gabriel Radanne,
Gabriel Scherer and Xavier Leroy)
+- #9275: Short circuit simple inclusion checks
+ (Leo White, review by Thomas Refis)
+
### Compiler distribution build system:
- #2267: merge generation of header programs, also fixing parallel build on
- #8508: refresh \moduleref macro
(Florian Angeletti, review by Gabriel Scherer)
+- 9410: replaced fibonacci example with gcd of coreexamples manual
+ (Anukriti Kumar, review by San Vu Ngoc, Florian Angeletti, Léo Andrès)
+
### Code generation and optimizations:
- #7725, #1754: improve AFL instrumentation for objects and lazy values.
platforms, making this option unusable on platforms where it wasn't.
(Jérémie Dimino, review by Sébastien Hinderer and Xavier Leroy)
+- #9349: Support [@inlined hint] attribute.
+ (Leo White, review by Stephen Dolan)
+
### Runtime system:
- #515 #676 #7173: Add a public C API for weak arrays and
make tests
----
-5. Install in a new opam switch to try things out:
-+
-----
-opam compiler-conf install
-----
-+
-With opam 2, create a local opam switch with the compiler installed from
-the current source directory:
+6. Install in a new opam switch to try things out. With `opam` v2, create a local
+opam switch with the compiler installed from the current source directory:
+
----
opam switch create . --empty
opam install .
----
-6. You did it, Well done! Consult link:CONTRIBUTING.md[] to send your contribution upstream.
+7. You did it, Well done! Consult link:CONTRIBUTING.md[] to send your contribution upstream.
See our <<Development tips and tricks>> for various helpful details,
for example on how to automatically <<opam compiler script,create an
== Development tips and tricks
-=== opam compiler script
+=== Keep merge commits when merging and cherry-picking Github PRs
-The separately-distributed script
-https://github.com/gasche/opam-compiler-conf[`opam-compiler-conf`] can
-be used to easily build opam switches out of a git branch of the
-compiler distribution. This lets you easily install and test opam
-packages from an under-modification compiler version.
+Having the Github PR number show up in the git log is very useful for
+later triaging. We recently disabled the "Rebase and merge" button,
+precisely because it does not produce a merge commit.
+
+When you cherry-pick a PR in another branch, please cherry-pick this
+merge-style commit rather than individual commits, whenever
+possible. (Picking a merge commit typically requires the `-m 1`
+option.) You should also use the `-x` option to include the hash of
+the original commit in the commit message.
+
+----
+git cherry-pick -x -m 1 <merge-commit-hash>
+----
+
+=== Testing with `opam`
+
+To test a particular branch `branch` of a public git repository
+`$REPO` of the compiler in an `opam` v2 switch issue:
+
+----
+opam switch create ocaml-branch --empty
+# Replace $VERSION by the trunk version
+opam pin add ocaml-variants.$VERSION+branch git+https://$REPO#branch
+----
=== Useful Makefile targets
ROOTDIR = .
+# The configure and *clean targets can all be run without running ./configure
+# first.
+# If no goals were specified (i.e. `make`), add defaultentry (since it requires
+# ./configure to be run)
+CAN_BE_UNCONFIGURED := $(strip \
+ $(filter-out partialclean clean distclean configure, \
+ $(if $(MAKECMDGOALS),$(MAKECMDGOALS),defaultentry)))
+
+ifeq "$(CAN_BE_UNCONFIGURED)" ""
+-include Makefile.config
+-include Makefile.common
+else
include Makefile.config
include Makefile.common
+endif
.PHONY: defaultentry
ifeq "$(NATIVE_COMPILER)" "true"
CAMLC=$(BOOT_OCAMLC) -g -nostdlib -I boot -use-prims runtime/primitives
CAMLOPT=$(CAMLRUN) ./ocamlopt -g -nostdlib -I stdlib -I otherlibs/dynlink
-ARCHES=amd64 i386 arm arm64 power s390x
+ARCHES=amd64 i386 arm arm64 power s390x riscv
INCLUDES=-I utils -I parsing -I typing -I bytecomp -I file_formats \
-I lambda -I middle_end -I middle_end/closure \
-I middle_end/flambda -I middle_end/flambda/base_types \
DEPINCLUDES=$(INCLUDES)
OCAMLDOC_OPT=$(WITH_OCAMLDOC:=.opt)
+OCAMLTEST_OPT=$(WITH_OCAMLTEST:=.opt)
-UTILS=utils/config.cmo utils/build_path_prefix_map.cmo utils/misc.cmo \
- utils/identifiable.cmo utils/numbers.cmo utils/arg_helper.cmo \
- utils/clflags.cmo utils/profile.cmo utils/load_path.cmo \
- utils/terminfo.cmo utils/ccomp.cmo utils/warnings.cmo \
- utils/consistbl.cmo utils/strongly_connected_components.cmo \
- utils/targetint.cmo utils/int_replace_polymorphic_compare.cmo \
- utils/domainstate.cmo
-
-PARSING=parsing/location.cmo parsing/longident.cmo \
- parsing/docstrings.cmo parsing/syntaxerr.cmo \
- parsing/ast_helper.cmo \
- parsing/pprintast.cmo \
- parsing/camlinternalMenhirLib.cmo parsing/parser.cmo \
- parsing/lexer.cmo parsing/parse.cmo parsing/printast.cmo \
- parsing/ast_mapper.cmo parsing/ast_iterator.cmo parsing/attr_helper.cmo \
- parsing/builtin_attributes.cmo parsing/ast_invariants.cmo parsing/depend.cmo
-
-TYPING=typing/ident.cmo typing/path.cmo \
- typing/primitive.cmo typing/type_immediacy.cmo typing/types.cmo \
- typing/btype.cmo typing/oprint.cmo \
- typing/subst.cmo typing/predef.cmo \
- typing/datarepr.cmo file_formats/cmi_format.cmo \
- typing/persistent_env.cmo typing/env.cmo \
- typing/typedtree.cmo typing/printtyped.cmo typing/ctype.cmo \
- typing/printtyp.cmo typing/includeclass.cmo \
- typing/mtype.cmo typing/envaux.cmo typing/includecore.cmo \
- typing/tast_iterator.cmo typing/tast_mapper.cmo \
- file_formats/cmt_format.cmo typing/untypeast.cmo \
- typing/includemod.cmo typing/typetexp.cmo typing/printpat.cmo \
- typing/parmatch.cmo typing/stypes.cmo \
- typing/typedecl_properties.cmo typing/typedecl_variance.cmo \
- typing/typedecl_unboxed.cmo typing/typedecl_immediacy.cmo \
- typing/typedecl.cmo typing/typeopt.cmo \
- typing/rec_check.cmo typing/typecore.cmo typing/typeclass.cmo \
- typing/typemod.cmo
-
-LAMBDA=lambda/debuginfo.cmo \
- lambda/lambda.cmo lambda/printlambda.cmo \
- lambda/switch.cmo lambda/matching.cmo \
- lambda/translobj.cmo lambda/translattribute.cmo \
- lambda/translprim.cmo lambda/translcore.cmo \
- lambda/translclass.cmo lambda/translmod.cmo \
- lambda/simplif.cmo lambda/runtimedef.cmo
-
-COMP=\
- bytecomp/meta.cmo bytecomp/opcodes.cmo \
- bytecomp/bytesections.cmo bytecomp/dll.cmo \
- bytecomp/symtable.cmo \
- driver/pparse.cmo driver/compenv.cmo \
- driver/main_args.cmo driver/compmisc.cmo \
- driver/makedepend.cmo \
- driver/compile_common.cmo
-
-COMMON=$(UTILS) $(PARSING) $(TYPING) $(LAMBDA) $(COMP)
-
-BYTECOMP=bytecomp/instruct.cmo bytecomp/bytegen.cmo \
- bytecomp/printinstr.cmo bytecomp/emitcode.cmo \
- bytecomp/bytelink.cmo bytecomp/bytelibrarian.cmo bytecomp/bytepackager.cmo \
- driver/errors.cmo driver/compile.cmo
-
-ARCH_SPECIFIC =\
- asmcomp/arch.ml asmcomp/proc.ml asmcomp/CSE.ml asmcomp/selection.ml \
- asmcomp/scheduling.ml asmcomp/reload.ml
-
-INTEL_ASM=\
- asmcomp/x86_proc.cmo \
- asmcomp/x86_dsl.cmo \
- asmcomp/x86_gas.cmo \
- asmcomp/x86_masm.cmo
-
-ARCH_SPECIFIC_ASMCOMP=
-ifeq ($(ARCH),i386)
-ARCH_SPECIFIC_ASMCOMP=$(INTEL_ASM)
-endif
-ifeq ($(ARCH),amd64)
-ARCH_SPECIFIC_ASMCOMP=$(INTEL_ASM)
-endif
-
-ASMCOMP=\
- $(ARCH_SPECIFIC_ASMCOMP) \
- asmcomp/arch.cmo \
- asmcomp/cmm.cmo asmcomp/printcmm.cmo \
- asmcomp/reg.cmo asmcomp/debug/reg_with_debug_info.cmo \
- asmcomp/debug/reg_availability_set.cmo \
- asmcomp/mach.cmo asmcomp/proc.cmo \
- asmcomp/afl_instrument.cmo \
- asmcomp/strmatch.cmo \
- asmcomp/cmmgen_state.cmo \
- asmcomp/cmm_helpers.cmo \
- asmcomp/cmmgen.cmo \
- asmcomp/interval.cmo \
- asmcomp/printmach.cmo asmcomp/selectgen.cmo \
- asmcomp/spacetime_profiling.cmo asmcomp/selection.cmo \
- asmcomp/comballoc.cmo \
- asmcomp/CSEgen.cmo asmcomp/CSE.cmo \
- asmcomp/liveness.cmo \
- asmcomp/spill.cmo asmcomp/split.cmo \
- asmcomp/interf.cmo asmcomp/coloring.cmo \
- asmcomp/linscan.cmo \
- asmcomp/reloadgen.cmo asmcomp/reload.cmo \
- asmcomp/deadcode.cmo \
- asmcomp/linear.cmo asmcomp/printlinear.cmo asmcomp/linearize.cmo \
- asmcomp/debug/available_regs.cmo \
- asmcomp/debug/compute_ranges_intf.cmo \
- asmcomp/debug/compute_ranges.cmo \
- asmcomp/schedgen.cmo asmcomp/scheduling.cmo \
- asmcomp/branch_relaxation_intf.cmo \
- asmcomp/branch_relaxation.cmo \
- asmcomp/emitaux.cmo asmcomp/emit.cmo asmcomp/asmgen.cmo \
- asmcomp/asmlink.cmo asmcomp/asmlibrarian.cmo asmcomp/asmpackager.cmo \
- driver/opterrors.cmo driver/optcompile.cmo
-
-# Files under middle_end/ are not to reference files under asmcomp/.
-# This ensures that the middle end can be linked (e.g. for objinfo) even when
-# the native code compiler is not present for some particular target.
-
-MIDDLE_END_CLOSURE=\
- middle_end/closure/closure.cmo \
- middle_end/closure/closure_middle_end.cmo
-
-# Owing to dependencies through [Compilenv], which would be
-# difficult to remove, some of the lower parts of Flambda (anything that is
-# saved in a .cmx file) have to be included in the [MIDDLE_END] stanza, below.
-MIDDLE_END_FLAMBDA=\
- middle_end/flambda/import_approx.cmo \
- middle_end/flambda/lift_code.cmo \
- middle_end/flambda/closure_conversion_aux.cmo \
- middle_end/flambda/closure_conversion.cmo \
- middle_end/flambda/initialize_symbol_to_let_symbol.cmo \
- middle_end/flambda/lift_let_to_initialize_symbol.cmo \
- middle_end/flambda/find_recursive_functions.cmo \
- middle_end/flambda/invariant_params.cmo \
- middle_end/flambda/inconstant_idents.cmo \
- middle_end/flambda/alias_analysis.cmo \
- middle_end/flambda/lift_constants.cmo \
- middle_end/flambda/share_constants.cmo \
- middle_end/flambda/simplify_common.cmo \
- middle_end/flambda/remove_unused_arguments.cmo \
- middle_end/flambda/remove_unused_closure_vars.cmo \
- middle_end/flambda/remove_unused_program_constructs.cmo \
- middle_end/flambda/simplify_boxed_integer_ops.cmo \
- middle_end/flambda/simplify_primitives.cmo \
- middle_end/flambda/inlining_stats_types.cmo \
- middle_end/flambda/inlining_stats.cmo \
- middle_end/flambda/inline_and_simplify_aux.cmo \
- middle_end/flambda/remove_free_vars_equal_to_args.cmo \
- middle_end/flambda/extract_projections.cmo \
- middle_end/flambda/augment_specialised_args.cmo \
- middle_end/flambda/unbox_free_vars_of_closures.cmo \
- middle_end/flambda/unbox_specialised_args.cmo \
- middle_end/flambda/unbox_closures.cmo \
- middle_end/flambda/inlining_transforms.cmo \
- middle_end/flambda/inlining_decision.cmo \
- middle_end/flambda/inline_and_simplify.cmo \
- middle_end/flambda/ref_to_variables.cmo \
- middle_end/flambda/flambda_invariants.cmo \
- middle_end/flambda/traverse_for_exported_symbols.cmo \
- middle_end/flambda/build_export_info.cmo \
- middle_end/flambda/closure_offsets.cmo \
- middle_end/flambda/un_anf.cmo \
- middle_end/flambda/flambda_to_clambda.cmo \
- middle_end/flambda/flambda_middle_end.cmo
-
-MIDDLE_END=\
- middle_end/internal_variable_names.cmo \
- middle_end/linkage_name.cmo \
- middle_end/compilation_unit.cmo \
- middle_end/variable.cmo \
- middle_end/flambda/base_types/closure_element.cmo \
- middle_end/flambda/base_types/closure_id.cmo \
- middle_end/symbol.cmo \
- middle_end/backend_var.cmo \
- middle_end/clambda_primitives.cmo \
- middle_end/printclambda_primitives.cmo \
- middle_end/clambda.cmo \
- middle_end/printclambda.cmo \
- middle_end/semantics_of_primitives.cmo \
- middle_end/convert_primitives.cmo \
- middle_end/flambda/base_types/id_types.cmo \
- middle_end/flambda/base_types/export_id.cmo \
- middle_end/flambda/base_types/tag.cmo \
- middle_end/flambda/base_types/mutable_variable.cmo \
- middle_end/flambda/base_types/set_of_closures_id.cmo \
- middle_end/flambda/base_types/set_of_closures_origin.cmo \
- middle_end/flambda/base_types/closure_origin.cmo \
- middle_end/flambda/base_types/var_within_closure.cmo \
- middle_end/flambda/base_types/static_exception.cmo \
- middle_end/flambda/pass_wrapper.cmo \
- middle_end/flambda/allocated_const.cmo \
- middle_end/flambda/parameter.cmo \
- middle_end/flambda/projection.cmo \
- middle_end/flambda/flambda.cmo \
- middle_end/flambda/flambda_iterators.cmo \
- middle_end/flambda/flambda_utils.cmo \
- middle_end/flambda/freshening.cmo \
- middle_end/flambda/effect_analysis.cmo \
- middle_end/flambda/inlining_cost.cmo \
- middle_end/flambda/simple_value_approx.cmo \
- middle_end/flambda/export_info.cmo \
- middle_end/flambda/export_info_for_pack.cmo \
- middle_end/compilenv.cmo \
- $(MIDDLE_END_CLOSURE) \
- $(MIDDLE_END_FLAMBDA)
-
-OPTCOMP=$(MIDDLE_END) $(ASMCOMP)
-
-TOPLEVEL=toplevel/genprintval.cmo toplevel/toploop.cmo \
- toplevel/trace.cmo toplevel/topdirs.cmo toplevel/topmain.cmo
-
-OPTTOPLEVEL=toplevel/genprintval.cmo toplevel/opttoploop.cmo \
- toplevel/opttopdirs.cmo toplevel/opttopmain.cmo
BYTESTART=driver/main.cmo
OPTSTART=driver/optmain.cmo
else
endif
+# targets for the compilerlibs/*.{cma,cmxa} archives
+include compilerlibs/Makefile.compilerlibs
+
# The configuration file
utils/config.ml: utils/config.mlp Makefile.config utils/Makefile
utils/domainstate.mli: utils/domainstate.mli.c runtime/caml/domain_state.tbl
$(CPP) -I runtime/caml $< > $@
+configure: configure.ac aclocal.m4 VERSION tools/autogen
+ tools/autogen
+
.PHONY: partialclean
partialclean::
rm -f utils/config.ml utils/domainstate.ml utils/domainstate.mli
$(MAKE) ocaml
$(MAKE) opt-core
$(MAKE) ocamlc.opt
- $(MAKE) otherlibraries $(WITH_DEBUGGER) $(WITH_OCAMLDOC) ocamltest
+ $(MAKE) otherlibraries $(WITH_DEBUGGER) $(WITH_OCAMLDOC) \
+ $(WITH_OCAMLTEST)
$(MAKE) ocamlopt.opt
$(MAKE) otherlibrariesopt
$(MAKE) ocamllex.opt ocamltoolsopt ocamltoolsopt.opt $(OCAMLDOC_OPT) \
- ocamltest.opt
-ifneq "$(WITH_OCAMLDOC)" ""
+ $(OCAMLTEST_OPT)
+ifeq "$(WITH_OCAMLDOC)-$(STDLIB_MANPAGES)" "ocamldoc-true"
$(MAKE) manpages
endif
.PHONY: all
all: coreall
$(MAKE) ocaml
- $(MAKE) otherlibraries $(WITH_DEBUGGER) $(WITH_OCAMLDOC) ocamltest
-ifneq "$(WITH_OCAMLDOC)" ""
+ $(MAKE) otherlibraries $(WITH_DEBUGGER) $(WITH_OCAMLDOC) \
+ $(WITH_OCAMLTEST)
+ifeq "$(WITH_OCAMLDOC)-$(STDLIB_MANPAGES)" "ocamldoc-true"
$(MAKE) manpages
endif
# The clean target
clean:: partialclean
-# Shared parts of the system
-
-compilerlibs/ocamlcommon.cma: $(COMMON)
- $(CAMLC) -a -linkall -o $@ $^
-partialclean::
- rm -f compilerlibs/ocamlcommon.cma
-
# The bytecode compiler
-compilerlibs/ocamlbytecomp.cma: $(BYTECOMP)
- $(CAMLC) -a -o $@ $^
-partialclean::
- rm -f compilerlibs/ocamlbytecomp.cma
-
ocamlc: compilerlibs/ocamlcommon.cma compilerlibs/ocamlbytecomp.cma $(BYTESTART)
$(CAMLC) $(LINKFLAGS) -compat-32 -o $@ $^
# The native-code compiler
-compilerlibs/ocamloptcomp.cma: $(OPTCOMP)
- $(CAMLC) -a -o $@ $^
-
-partialclean::
- rm -f compilerlibs/ocamloptcomp.cma
-
ocamlopt: compilerlibs/ocamlcommon.cma compilerlibs/ocamloptcomp.cma \
$(OPTSTART)
$(CAMLC) $(LINKFLAGS) -o $@ $^
# The toplevel
-compilerlibs/ocamltoplevel.cma: $(TOPLEVEL)
- $(CAMLC) -a -o $@ $^
-partialclean::
- rm -f compilerlibs/ocamltoplevel.cma
-
ocaml_dependencies := \
compilerlibs/ocamlcommon.cma \
compilerlibs/ocamlbytecomp.cma \
beforedepend:: parsing/lexer.ml
-# Shared parts of the system compiled with the native-code compiler
-
-compilerlibs/ocamlcommon.cmxa: $(COMMON:.cmo=.cmx)
- $(CAMLOPT) -a -linkall -o $@ $^
-partialclean::
- rm -f compilerlibs/ocamlcommon.cmxa compilerlibs/ocamlcommon.$(A)
-
# The bytecode compiler compiled with the native-code compiler
-compilerlibs/ocamlbytecomp.cmxa: $(BYTECOMP:.cmo=.cmx)
- $(CAMLOPT) -a $(OCAML_NATDYNLINKOPTS) -o $@ $^
-partialclean::
- rm -f compilerlibs/ocamlbytecomp.cmxa compilerlibs/ocamlbytecomp.$(A)
-
ocamlc.opt: compilerlibs/ocamlcommon.cmxa compilerlibs/ocamlbytecomp.cmxa \
$(BYTESTART:.cmo=.cmx)
$(CAMLOPT_CMD) $(LINKFLAGS) -o $@ $^ -cclib "$(BYTECCLIBS)"
# The native-code compiler compiled with itself
-compilerlibs/ocamloptcomp.cmxa: $(OPTCOMP:.cmo=.cmx)
- $(CAMLOPT) -a -o $@ $^
-partialclean::
- rm -f compilerlibs/ocamloptcomp.cmxa compilerlibs/ocamloptcomp.$(A)
-
ocamlopt.opt: compilerlibs/ocamlcommon.cmxa compilerlibs/ocamloptcomp.cmxa \
$(OPTSTART:.cmo=.cmx)
$(CAMLOPT_CMD) $(LINKFLAGS) -o $@ $^
partialclean::
rm -f ocamlopt.opt
-$(COMMON:.cmo=.cmx) $(BYTECOMP:.cmo=.cmx) $(OPTCOMP:.cmo=.cmx): ocamlopt
-
# The predefined exceptions and primitives
runtime/primitives:
cd stdlib; $(LN) ../runtime/libcamlrun.$(A) .
clean::
$(MAKE) -C runtime clean
- rm -f stdlib/libcamlrun.$(A)
+ rm -f stdlib/libcamlrun.a stdlib/libcamlrun.lib
otherlibs_all := bigarray dynlink raw_spacetime_lib \
str systhreads unix win32unix
stdlib/libasmrun.$(A): runtime/libasmrun.$(A)
cp $< $@
clean::
- rm -f stdlib/libasmrun.$(A)
+ rm -f stdlib/libasmrun.a stdlib/libasmrun.lib
# The standard library
grep -Ev internal\|obj\|spacetime\|stdLabels\|moreLabels |\
tools/lintapidiff.opt $(VERSIONS)
-# The middle end.
-
-compilerlibs/ocamlmiddleend.cma: $(MIDDLE_END)
- $(CAMLC) -a -o $@ $^
-compilerlibs/ocamlmiddleend.cmxa: $(MIDDLE_END:%.cmo=%.cmx)
- $(CAMLOPT) -a -o $@ $^
-partialclean::
- rm -f compilerlibs/ocamlmiddleend.cma \
- compilerlibs/ocamlmiddleend.cmxa \
- compilerlibs/ocamlmiddleend.$(A)
-
# Tools
.PHONY: ocamltools
# The native toplevel
-compilerlibs/ocamlopttoplevel.cmxa: $(OPTTOPLEVEL:.cmo=.cmx)
- $(CAMLOPT) -a -o $@ $^
-partialclean::
- rm -f compilerlibs/ocamlopttoplevel.cmxa
-
# When the native toplevel executable has an extension (e.g. ".exe"),
# provide a phony 'ocamlnat' synonym
$(CAMLOPT_CMD) $(LINKFLAGS) -linkall -o $@ $^
partialclean::
- rm -f ocamlnat$(EXE)
+ rm -f ocamlnat ocamlnat.exe
toplevel/opttoploop.cmx: otherlibs/dynlink/dynlink.cmxa
lambda middle_end/closure middle_end/flambda \
middle_end/flambda/base_types asmcomp/debug \
driver toplevel tools; do \
- rm -f $$d/*.cm[ioxt] $$d/*.cmti $$d/*.annot $$d/*.$(S) \
- $$d/*.$(O) $$d/*.$(SO); \
+ rm -f $$d/*.cm[ioxt] $$d/*.cmti $$d/*.annot $$d/*.s $$d/*.asm \
+ $$d/*.o $$d/*.obj $$d/*.so $$d/*.dll; \
done
.PHONY: depend
.PHONY: distclean
distclean: clean
- rm -f boot/ocamlrun boot/ocamlrun$(EXE) boot/camlheader \
- boot/*.cm* boot/libcamlrun.$(A) boot/ocamlc.opt
- rm -f Makefile.config runtime/caml/m.h runtime/caml/s.h
+ rm -f boot/ocamlrun boot/ocamlrun boot/ocamlrun.exe boot/camlheader \
+ boot/*.cm* boot/libcamlrun.a boot/libcamlrun.lib boot/ocamlc.opt
+ rm -f Makefile.config Makefile.common runtime/caml/m.h runtime/caml/s.h
+ rm -rf autom4te.cache
+ rm -f config.log config.status libtool
+ rm -f tools/eventlog_metadata
rm -f tools/*.bak
rm -f ocaml ocamlc
rm -f testsuite/_log*
include .depend
-Makefile.config Makefile.common:
+
+ifneq "$(strip $(CAN_BE_UNCONFIGURED))" ""
+Makefile.config Makefile.common: config.status
+
+config.status:
@echo "Please refer to the installation instructions:"
@echo "- In file INSTALL for Unix systems."
@echo "- In file README.win32.adoc for Windows systems."
@echo " make install"
@echo "should work."
@false
+endif
# Whether the architecture has 64 bits
ARCH64=@arch64@
+# Endianess for this architecture
+ENDIANNESS=@endianness@
+
### Name of architecture model for the native-code compiler.
### Some architectures come in several slightly different flavors
### that share a common code generator. This variable tailors the
### Which libraries to compile and install
# Currently available:
-# unix Unix system calls
-# str Regular expressions and high-level string processing
-# systhreads Same as threads, requires POSIX threads
-# dynlink Dynamic linking of bytecode
-# bigarray Large, multidimensional numerical arrays
+# bigarray Large, multidimensional numerical arrays
+# (legacy support: this library is now part of the
+# Standard Library)
+# dynlink Dynamic linking (bytecode and native)
+# (win32)unix Unix system calls
+# str Regular expressions and high-level string processing
+# raw_spacetime_lib Parsing of spacetime traces
+# systhreads Same as threads, requires POSIX threads
OTHERLIBRARIES=@otherlibraries@
### Link-time options to ocamlc or ocamlopt for linking with POSIX threads
NATDYNLINKOPTS=@natdynlinkopts@
SYSLIB=@syslib@
MKLIB=@mklib@
-OCAMLOPT_CFLAGS=@ocamlopt_cflags@
-OCAMLOPT_CPPFLAGS=@ocamlopt_cppflags@
+# #7678: ocamlopt uses these only to compile .c files, and the behaviour for the
+# two drivers should be identical.
+OCAMLOPT_CFLAGS=@ocamlc_cflags@
+OCAMLOPT_CPPFLAGS=@ocamlc_cppflags@
NATIVECCLIBS=@nativecclibs@
SYSTHREAD_SUPPORT=@systhread_support@
PACKLD=@PACKLD@
WITH_DEBUGGER=@with_debugger@
WITH_CAMLTEX=@with_camltex@
WITH_OCAMLDOC=@ocamldoc@
+WITH_OCAMLTEST=@ocamltest@
ASM_CFI_SUPPORTED=@asm_cfi_supported@
WITH_FRAME_POINTERS=@frame_pointers@
WITH_SPACETIME=@spacetime@
# variable. Note that for Windows we add Unix-syntax directory names in
# PATH, and Cygwin will translate it to Windows syntax.
-include $(TOPDIR)/Makefile.config
+-include $(TOPDIR)/Makefile.config
# Make sure USE_RUNTIME is defined
USE_RUNTIME ?=
|=====
-| Branch `trunk` | Branch `4.08` | Branch `4.07` | Branch `4.06` | Branch `4.05`
+| Branch `trunk` | Branch `4.10` | Branch `4.09` | Branch `4.08` | Branch `4.07` | Branch `4.06` | Branch `4.05`
| image:https://travis-ci.org/ocaml/ocaml.svg?branch=trunk["TravisCI Build Status (trunk branch)",
link="https://travis-ci.org/ocaml/ocaml"]
image:https://ci.appveyor.com/api/projects/status/github/ocaml/ocaml?branch=trunk&svg=true["AppVeyor Build Status (trunk branch)",
link="https://ci.appveyor.com/project/avsm/ocaml"]
+| image:https://travis-ci.org/ocaml/ocaml.svg?branch=4.10["TravisCI Build Status (4.10 branch)",
+ link="https://travis-ci.org/ocaml/ocaml"]
+ image:https://ci.appveyor.com/api/projects/status/github/ocaml/ocaml?branch=4.10&svg=true["AppVeyor Build Status (4.10 branch)",
+ link="https://ci.appveyor.com/project/avsm/ocaml"]
+| image:https://travis-ci.org/ocaml/ocaml.svg?branch=4.09["TravisCI Build Status (4.09 branch)",
+ link="https://travis-ci.org/ocaml/ocaml"]
+ image:https://ci.appveyor.com/api/projects/status/github/ocaml/ocaml?branch=4.09&svg=true["AppVeyor Build Status (4.09 branch)",
+ link="https://ci.appveyor.com/project/avsm/ocaml"]
| image:https://travis-ci.org/ocaml/ocaml.svg?branch=4.08["TravisCI Build Status (4.08 branch)",
link="https://travis-ci.org/ocaml/ocaml"]
image:https://ci.appveyor.com/api/projects/status/github/ocaml/ocaml?branch=4.08&svg=true["AppVeyor Build Status (4.08 branch)",
| ARM 32 bits | Linux | FreeBSD, NetBSD, OpenBSD
| Power 64 bits | Linux |
| Power 32 bits | | Linux
+| RISC-V 64 bits | Linux |
| IBM Z (s390x) | Linux |
|====
The OCaml manual is distributed in HTML, PDF, and Emacs
Info files. It is available at
-http://caml.inria.fr/pub/docs/manual-ocaml/
+https://ocaml.org/releases/latest/manual.html
== Availability
The complete OCaml distribution can be accessed at
-http://ocaml.org/docs/install.html
+https://ocaml.org/docs/install.html
== Keeping in Touch with the Caml Community
https://sympa.inria.fr/sympa/subscribe/caml-list
+An alternative archive of the mailing list is also available at
+
+https://inbox.ocaml.org/
+
You can also access a newer discussion forum at
https://discuss.ocaml.org/
around the internet for getting in touch with the OCaml and ML family language
community. These can be accessed at
-http://ocaml.org/community/
+https://ocaml.org/community/
In particular, the IRC channel `#ocaml` on https://freenode.net/[Freenode] has a
long history and welcomes questions.
-4.10.1
+4.11.0
# The version string is the first line of this file.
# It must be in the format described in stdlib/sys.mli
cache:
- C:\cygwin64\var\cache\setup
+ - C:\projects\cache
install:
# This is a hangover from monitoring effects of MPR#7452
(* these cases add no logging, but instrument subexpressions *)
| Clet (v, e, body) -> Clet (v, instrument e, instrument body)
+ | Clet_mut (v, k, e, body) ->
+ Clet_mut (v, k, instrument e, instrument body)
| Cphantom_let (v, defining_expr, body) ->
Cphantom_let (v, defining_expr, instrument body)
| Cassign (v, e) -> Cassign (v, instrument e)
open X86_proc
open X86_dsl
module String = Misc.Stdlib.String
+module Int = Numbers.Int
(* [Branch_relaxation] is not used in this file, but is required by
emit.mlp files for certain other targets; the reference here ensures
let label s = sym (emit_label s)
-let def_label s = D.label (emit_label s)
+(* For Spacetime, keep track of code labels that have been emitted. *)
+let used_labels = ref Int.Set.empty
+
+let mark_used lbl =
+ if Config.spacetime && not (Int.Set.mem lbl !used_labels) then begin
+ used_labels := Int.Set.add lbl !used_labels
+ end
+
+let def_label ?typ s =
+ mark_used s;
+ D.label ?typ (emit_label s)
let emit_Llabel fallthrough lbl =
if not fallthrough && !fastcode_flag then D.align 4;
(* Record live pointers at call points -- see Emitaux *)
-let record_frame_label ?label live raise_ dbg =
+let record_frame_label ?label live dbg =
let lbl =
match label with
| None -> new_label()
)
live;
record_frame_descr ~label:lbl ~frame_size:(frame_size())
- ~live_offset:!live_offset ~raise_frame:raise_ dbg;
+ ~live_offset:!live_offset dbg;
lbl
-let record_frame ?label live raise_ dbg =
- let lbl = record_frame_label ?label live raise_ dbg in
+let record_frame ?label live dbg =
+ let lbl = record_frame_label ?label live dbg in
def_label lbl
(* Spacetime instrumentation *)
(* Record calls to the GC -- we've moved them out of the way *)
type gc_call =
- { gc_size: int; (* Allocation size, in bytes *)
- gc_lbl: label; (* Entry label *)
+ { gc_lbl: label; (* Entry label *)
gc_return_lbl: label; (* Where to branch after GC *)
gc_frame: label; (* Label of frame descriptor *)
gc_spacetime : (X86_ast.arg * int) option;
assert Config.spacetime;
spacetime_before_uninstrumented_call ~node_ptr ~index
end;
- begin match gc.gc_size with
- | 16 -> emit_call "caml_call_gc1"
- | 24 -> emit_call "caml_call_gc2"
- | 32 -> emit_call "caml_call_gc3"
- | n -> I.add (int n) r15;
- emit_call "caml_call_gc"
- end;
+ emit_call "caml_call_gc";
def_label gc.gc_frame;
I.jmp (label gc.gc_return_lbl)
let bound_error_label ?label dbg ~spacetime =
if !Clflags.debug || Config.spacetime then begin
let lbl_bound_error = new_label() in
- let lbl_frame = record_frame_label ?label Reg.Set.empty false dbg in
+ let lbl_frame = record_frame_label ?label Reg.Set.empty (Dbg_other dbg) in
bound_error_sites :=
{ bd_lbl = lbl_bound_error; bd_frame = lbl_frame;
bd_spacetime = spacetime; } :: !bound_error_sites;
load_symbol_addr s (res i 0)
| Lop(Icall_ind { label_after; }) ->
I.call (arg i 0);
- record_frame i.live false i.dbg ~label:label_after
+ record_frame i.live (Dbg_other i.dbg) ~label:label_after
| Lop(Icall_imm { func; label_after; }) ->
add_used_symbol func;
emit_call func;
- record_frame i.live false i.dbg ~label:label_after
+ record_frame i.live (Dbg_other i.dbg) ~label:label_after
| Lop(Itailcall_ind { label_after; }) ->
output_epilogue begin fun () ->
I.jmp (arg i 0);
if Config.spacetime then begin
- record_frame Reg.Set.empty false i.dbg ~label:label_after
+ record_frame Reg.Set.empty (Dbg_other i.dbg) ~label:label_after
end
end
| Lop(Itailcall_imm { func; label_after; }) ->
end
end;
if Config.spacetime then begin
- record_frame Reg.Set.empty false i.dbg ~label:label_after
+ record_frame Reg.Set.empty (Dbg_other i.dbg) ~label:label_after
end
| Lop(Iextcall { func; alloc; label_after; }) ->
add_used_symbol func;
if alloc then begin
load_symbol_addr func rax;
emit_call "caml_c_call";
- record_frame i.live false i.dbg ~label:label_after;
+ record_frame i.live (Dbg_other i.dbg) ~label:label_after;
if system <> S_win64 then begin
(* TODO: investigate why such a diff.
This comes from:
end else begin
emit_call func;
if Config.spacetime then begin
- record_frame Reg.Set.empty false i.dbg ~label:label_after
+ record_frame Reg.Set.empty (Dbg_other i.dbg) ~label:label_after
end
end
| Lop(Istackoffset n) ->
| Double | Double_u ->
I.movsd (arg i 0) (addressing addr REAL8 i 1)
end
- | Lop(Ialloc { bytes = n; label_after_call_gc; spacetime_index; }) ->
+ | Lop(Ialloc { bytes = n; label_after_call_gc; spacetime_index; dbginfo }) ->
+ assert (n <= (Config.max_young_wosize + 1) * Arch.size_addr);
if !fastcode_flag then begin
- let lbl_redo = new_label() in
- def_label lbl_redo;
I.sub (int n) r15;
I.cmp (domain_field Domainstate.Domain_young_limit) r15;
let lbl_call_gc = new_label() in
- let dbg =
- if not Config.spacetime then Debuginfo.none
- else i.dbg
- in
let lbl_frame =
- record_frame_label ?label:label_after_call_gc i.live false dbg
+ record_frame_label ?label:label_after_call_gc i.live (Dbg_alloc dbginfo)
in
I.jb (label lbl_call_gc);
+ let lbl_after_alloc = new_label() in
+ def_label lbl_after_alloc;
I.lea (mem64 NONE 8 R15) (res i 0);
let gc_spacetime =
if not Config.spacetime then None
else Some (arg i 0, spacetime_index)
in
call_gc_sites :=
- { gc_size = n;
- gc_lbl = lbl_call_gc;
- gc_return_lbl = lbl_redo;
+ { gc_lbl = lbl_call_gc;
+ gc_return_lbl = lbl_after_alloc;
gc_frame = lbl_frame;
gc_spacetime; } :: !call_gc_sites
end else begin
| 24 -> emit_call "caml_alloc2"
| 32 -> emit_call "caml_alloc3"
| _ ->
- I.mov (int n) rax;
+ I.sub (int n) r15;
emit_call "caml_allocN"
end;
let label =
- record_frame_label ?label:label_after_call_gc i.live false
- Debuginfo.none
+ record_frame_label ?label:label_after_call_gc i.live
+ (Dbg_alloc dbginfo)
in
def_label label;
I.lea (mem64 NONE 8 R15) (res i 0)
| Lambda.Raise_regular ->
I.mov (int 0) (domain_field Domainstate.Domain_backtrace_pos);
emit_call "caml_raise_exn";
- record_frame Reg.Set.empty true i.dbg
+ record_frame Reg.Set.empty (Dbg_raise i.dbg)
| Lambda.Raise_reraise ->
emit_call "caml_raise_exn";
- record_frame Reg.Set.empty true i.dbg
+ record_frame Reg.Set.empty (Dbg_raise i.dbg)
| Lambda.Raise_notrace ->
I.mov (domain_field Domainstate.Domain_exception_pointer) rsp;
I.pop (domain_field Domainstate.Domain_exception_pointer);
reset_imp_table();
float_constants := [];
all_functions := [];
+ used_labels := Int.Set.empty;
if system = S_win64 then begin
D.extrn "caml_call_gc" NEAR;
- D.extrn "caml_call_gc1" NEAR;
- D.extrn "caml_call_gc2" NEAR;
- D.extrn "caml_call_gc3" NEAR;
D.extrn "caml_c_call" NEAR;
D.extrn "caml_allocN" NEAR;
D.extrn "caml_alloc1" NEAR;
begin match fundecl.fun_spacetime_shape with
| None -> ()
| Some shape ->
- let funsym = emit_symbol fundecl.fun_name in
- D.comment ("Shape for " ^ funsym ^ ":");
- D.qword (ConstLabel funsym);
- List.iter (fun (part_of_shape, label) ->
+ (* Instrumentation that refers to dead code may have been eliminated. *)
+ match List.filter (fun (_, l) -> Int.Set.mem l !used_labels) shape with
+ | [] -> ()
+ | shape ->
+ let funsym = emit_symbol fundecl.fun_name in
+ D.comment ("Shape for " ^ funsym ^ ":");
+ D.qword (ConstLabel funsym);
+ List.iter (fun (part_of_shape, label) ->
let tag =
match part_of_shape with
| Direct_call_point _ -> 1
| Indirect_call_point -> ()
| Allocation_point -> ()
end)
- shape;
+ shape;
D.qword (Const 0L)
end)
!all_functions;
emit_frames
{ efa_code_label = (fun l -> D.qword (ConstLabel (emit_label l)));
efa_data_label = (fun l -> D.qword (ConstLabel (emit_label l)));
+ efa_8 = (fun n -> D.byte (const n));
efa_16 = (fun n -> D.word (const n));
efa_32 = (fun n -> D.long (const_32 n));
efa_word = (fun n -> D.qword (const n));
efa_string = (fun s -> D.bytes (s ^ "\000"))
};
+ if system = S_linux then begin
+ let frametable = emit_symbol (Compilenv.make_symbol (Some "frametable")) in
+ D.size frametable (ConstSub (ConstThis, ConstLabel frametable))
+ end;
+
if Config.spacetime then begin
emit_spacetime_shapes ()
end;
100;101;102;103;104;105;106;107;
108;109;110;111;112;113;114;115])
+let destroyed_by_spacetime_at_alloc =
+ if Config.spacetime then
+ [| loc_spacetime_node_hole |]
+ else
+ [| |]
+
let destroyed_at_alloc =
let regs =
- if Config.spacetime then
- [| rax; loc_spacetime_node_hole |]
+ if X86_proc.use_plt then
+ destroyed_by_plt_stub
else
- [| rax |]
+ [| r11 |]
in
- Array.concat [regs; destroyed_by_plt_stub]
+ Array.concat [regs; destroyed_by_spacetime_at_alloc]
let destroyed_at_oper = function
Iop(Icall_ind _ | Icall_imm _ | Iextcall { alloc = true; }) ->
(* Record live pointers at call points *)
-let record_frame_label ?label live raise_ dbg =
+let record_frame_label ?label live dbg =
let lbl =
match label with
| None -> new_label()
| _ -> ())
live;
record_frame_descr ~label:lbl ~frame_size:(frame_size())
- ~live_offset:!live_offset ~raise_frame:raise_ dbg;
+ ~live_offset:!live_offset dbg;
lbl
-let record_frame ?label live raise_ dbg =
- let lbl = record_frame_label ?label live raise_ dbg in `{emit_label lbl}:`
+let record_frame ?label live dbg =
+ let lbl = record_frame_label ?label live dbg in `{emit_label lbl}:`
(* Record calls to the GC -- we've moved them out of the way *)
let bound_error_label ?label dbg =
if !Clflags.debug || !bound_error_sites = [] then begin
let lbl_bound_error = new_label() in
- let lbl_frame = record_frame_label ?label Reg.Set.empty false dbg in
+ let lbl_frame = record_frame_label ?label Reg.Set.empty (Dbg_other dbg) in
bound_error_sites :=
{ bd_lbl = lbl_bound_error;
bd_frame_lbl = lbl_frame } :: !bound_error_sites;
| Lop(Icall_ind { label_after; }) ->
if !arch >= ARMv5 then begin
` blx {emit_reg i.arg.(0)}\n`;
- `{record_frame i.live false i.dbg ~label:label_after}\n`; 1
+ `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n`; 1
end else begin
` mov lr, pc\n`;
` bx {emit_reg i.arg.(0)}\n`;
- `{record_frame i.live false i.dbg ~label:label_after}\n`; 2
+ `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n`; 2
end
| Lop(Icall_imm { func; label_after; }) ->
` {emit_call func}\n`;
- `{record_frame i.live false i.dbg ~label:label_after}\n`; 1
+ `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n`; 1
| Lop(Itailcall_ind { label_after = _; }) ->
output_epilogue begin fun () ->
if !contains_calls then
| Lop(Iextcall { func; alloc = true; label_after; }) ->
let ninstr = emit_load_symbol_addr (phys_reg 7 (* r7 *)) func in
` {emit_call "caml_c_call"}\n`;
- `{record_frame i.live false i.dbg ~label:label_after}\n`;
+ `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n`;
1 + ninstr
| Lop(Istackoffset n) ->
assert (n mod 8 = 0);
| Double_u -> "fstd"
| _ (* 32-bit quantities *) -> "str" in
` {emit_string instr} {emit_reg r}, {emit_addressing addr i.arg 1}\n`; 1
- | Lop(Ialloc { bytes = n; label_after_call_gc; }) ->
+ | Lop(Ialloc { bytes = n; label_after_call_gc; dbginfo }) ->
let lbl_frame =
- record_frame_label i.live false i.dbg ?label:label_after_call_gc
+ record_frame_label i.live (Dbg_alloc dbginfo) ?label:label_after_call_gc
in
if !fastcode_flag then begin
- let lbl_redo = new_label() in
- `{emit_label lbl_redo}:`;
- let first = ref true in
- let ninstr =
- decompose_intconst (Int32.of_int (n - 4)) (fun a ->
- if !first
- then ` sub {emit_reg i.res.(0)}, alloc_ptr, #{emit_int32 a}\n`
- else ` sub {emit_reg i.res.(0)}, {emit_reg i.res.(0)}, #{emit_int32 a}\n`;
- first := false) in
+ let ninstr = decompose_intconst
+ (Int32.of_int n)
+ (fun i ->
+ ` sub alloc_ptr, alloc_ptr, #{emit_int32 i}\n`) in
let offset = Domainstate.(idx_of_field Domain_young_limit) * 8 in
- let tmp = if i.res.(0).loc = Reg 8 (* r12 *) then phys_reg 7 (* r7 *)
- else phys_reg 8 (* r12 *)
- in
- ` ldr {emit_reg tmp}, [domain_state_ptr, {emit_int offset}]\n`;
- ` cmp {emit_reg i.res.(0)}, {emit_reg tmp}\n`;
+ ` ldr {emit_reg i.res.(0)}, [domain_state_ptr, {emit_int offset}]\n`;
+ ` cmp alloc_ptr, {emit_reg i.res.(0)}\n`;
let lbl_call_gc = new_label() in
- ` bls {emit_label lbl_call_gc}\n`;
- ` sub alloc_ptr, {emit_reg i.res.(0)}, #4\n`;
+ ` bcc {emit_label lbl_call_gc}\n`;
+ let lbl_after_alloc = new_label() in
+ `{emit_label lbl_after_alloc}:`;
+ ` add {emit_reg i.res.(0)}, alloc_ptr, #4\n`;
call_gc_sites :=
{ gc_lbl = lbl_call_gc;
- gc_return_lbl = lbl_redo;
+ gc_return_lbl = lbl_after_alloc;
gc_frame_lbl = lbl_frame } :: !call_gc_sites;
- 3 + ninstr
+ 4 + ninstr
end else begin
let ninstr =
begin match n with
` mov r12, #0\n`;
` str r12, [domain_state_ptr, {emit_int offset}]\n`;
` {emit_call "caml_raise_exn"}\n`;
- `{record_frame Reg.Set.empty true i.dbg}\n`; 3
+ `{record_frame Reg.Set.empty (Dbg_raise i.dbg)}\n`; 3
| Lambda.Raise_reraise ->
` {emit_call "caml_raise_exn"}\n`;
- `{record_frame Reg.Set.empty true i.dbg}\n`; 1
+ `{record_frame Reg.Set.empty (Dbg_raise i.dbg)}\n`; 1
| Lambda.Raise_notrace ->
` mov sp, trap_ptr\n`;
` pop \{trap_ptr, pc}\n`; 2
efa_data_label = (fun lbl ->
` .type {emit_label lbl}, %object\n`;
` .word {emit_label lbl}\n`);
+ efa_8 = (fun n -> ` .byte {emit_int n}\n`);
efa_16 = (fun n -> ` .short {emit_int n}\n`);
efa_32 = (fun n -> ` .long {emit_int32 n}\n`);
efa_word = (fun n -> ` .word {emit_int n}\n`);
(* Do not introduce a dependency to Cmm *)
type specific_operation =
- | Ifar_alloc of { bytes : int; label_after_call_gc : cmm_label option; }
+ | Ifar_alloc of { bytes : int; label_after_call_gc : cmm_label option;
+ dbginfo : Debuginfo.alloc_dbginfo }
| Ifar_intop_checkbound of { label_after_error : cmm_label option; }
| Ifar_intop_imm_checkbound of
{ bound : int; label_after_error : cmm_label option; }
(* Record live pointers at call points *)
-let record_frame_label ?label live raise_ dbg =
+let record_frame_label ?label live dbg =
let lbl =
match label with
| None -> new_label()
| _ -> ())
live;
record_frame_descr ~label:lbl ~frame_size:(frame_size())
- ~live_offset:!live_offset ~raise_frame:raise_ dbg;
+ ~live_offset:!live_offset dbg;
lbl
-let record_frame ?label live raise_ dbg =
- let lbl = record_frame_label ?label live raise_ dbg in `{emit_label lbl}:`
+let record_frame ?label live dbg =
+ let lbl = record_frame_label ?label live dbg in `{emit_label lbl}:`
(* Record calls to the GC -- we've moved them out of the way *)
let bound_error_label ?label dbg =
if !Clflags.debug || !bound_error_sites = [] then begin
let lbl_bound_error = new_label() in
- let lbl_frame = record_frame_label ?label Reg.Set.empty false dbg in
+ let lbl_frame = record_frame_label ?label Reg.Set.empty (Dbg_other dbg) in
bound_error_sites :=
{ bd_lbl = lbl_bound_error;
bd_frame_lbl = lbl_frame } :: !bound_error_sites;
| Lambda.Raise_notrace -> 4
end
- let relax_allocation ~num_bytes ~label_after_call_gc =
- Lop (Ispecific (Ifar_alloc { bytes = num_bytes; label_after_call_gc; }))
+ let relax_allocation ~num_bytes ~label_after_call_gc ~dbginfo =
+ Lop (Ispecific (Ifar_alloc { bytes = num_bytes; label_after_call_gc; dbginfo }))
let relax_intop_checkbound ~label_after_error =
Lop (Ispecific (Ifar_intop_checkbound { label_after_error; }))
(* Output the assembly code for allocation. *)
-let assembly_code_for_allocation ?label_after_call_gc i ~n ~far =
+let assembly_code_for_allocation ~label_after_call_gc i ~n ~far ~dbginfo =
let lbl_frame =
- record_frame_label ?label:label_after_call_gc i.live false i.dbg
+ record_frame_label ?label:label_after_call_gc i.live (Dbg_alloc dbginfo)
in
if !fastcode_flag then begin
- let lbl_redo = new_label() in
+ let lbl_after_alloc = new_label() in
let lbl_call_gc = new_label() in
(* n is at most Max_young_whsize * 8, i.e. currently 0x808,
so it is reasonable to assume n < 0x1_000. This makes
the generated code simpler. *)
assert (16 <= n && n < 0x1_000 && n land 0x7 = 0);
- (* Instead of checking whether young_ptr - n < young_limit, we check whether
- young_ptr - (n - 8) <= young_limit. It's equivalent, but this way around
- we can avoid mutating young_ptr on failed allocations, by doing the
- calculations in i.res.(0) instead of young_ptr. *)
- `{emit_label lbl_redo}:`;
- ` sub {emit_reg i.res.(0)}, {emit_reg reg_alloc_ptr}, #{emit_int (n - 8)}\n`;
- ` cmp {emit_reg i.res.(0)}, {emit_reg reg_alloc_limit}\n`;
+ ` sub {emit_reg reg_alloc_ptr}, {emit_reg reg_alloc_ptr}, #{emit_int n}\n`;
+ ` cmp {emit_reg reg_alloc_ptr}, {emit_reg reg_alloc_limit}\n`;
if not far then begin
- ` b.ls {emit_label lbl_call_gc}\n`
+ ` b.lo {emit_label lbl_call_gc}\n`
end else begin
let lbl = new_label () in
- ` b.hi {emit_label lbl}\n`;
+ ` b.cs {emit_label lbl}\n`;
` b {emit_label lbl_call_gc}\n`;
`{emit_label lbl}:\n`
end;
- ` sub {emit_reg reg_alloc_ptr}, {emit_reg i.res.(0)}, #8\n`;
+ `{emit_label lbl_after_alloc}:`;
+ ` add {emit_reg i.res.(0)}, {emit_reg reg_alloc_ptr}, #8\n`;
call_gc_sites :=
{ gc_lbl = lbl_call_gc;
- gc_return_lbl = lbl_redo;
+ gc_return_lbl = lbl_after_alloc;
gc_frame_lbl = lbl_frame } :: !call_gc_sites
end else begin
begin match n with
emit_load_symbol_addr i.res.(0) s
| Lop(Icall_ind { label_after; }) ->
` blr {emit_reg i.arg.(0)}\n`;
- `{record_frame i.live false i.dbg ~label:label_after}\n`
+ `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n`
| Lop(Icall_imm { func; label_after; }) ->
` bl {emit_symbol func}\n`;
- `{record_frame i.live false i.dbg ~label:label_after}\n`
+ `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n`
| Lop(Itailcall_ind { label_after = _; }) ->
output_epilogue (fun () -> ` br {emit_reg i.arg.(0)}\n`)
| Lop(Itailcall_imm { func; label_after = _; }) ->
| Lop(Iextcall { func; alloc = true; label_after; }) ->
emit_load_symbol_addr reg_x15 func;
` bl {emit_symbol "caml_c_call"}\n`;
- `{record_frame i.live false i.dbg ~label:label_after}\n`
+ `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n`
| Lop(Istackoffset n) ->
assert (n mod 16 = 0);
emit_stack_adjustment (-n);
| Word_int | Word_val | Double | Double_u ->
` str {emit_reg src}, {emit_addressing addr base}\n`
end
- | Lop(Ialloc { bytes = n; label_after_call_gc; }) ->
- assembly_code_for_allocation i ~n ~far:false ?label_after_call_gc
- | Lop(Ispecific (Ifar_alloc { bytes = n; label_after_call_gc; })) ->
- assembly_code_for_allocation i ~n ~far:true ?label_after_call_gc
+ | Lop(Ialloc { bytes = n; label_after_call_gc; dbginfo }) ->
+ assembly_code_for_allocation i ~n ~far:false ~label_after_call_gc ~dbginfo
+ | Lop(Ispecific (Ifar_alloc { bytes = n; label_after_call_gc; dbginfo })) ->
+ assembly_code_for_allocation i ~n ~far:true ~label_after_call_gc ~dbginfo
| Lop(Iintop(Icomp cmp)) ->
` cmp {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`;
` cset {emit_reg i.res.(0)}, {emit_string (name_for_comparison cmp)}\n`
let offset = Domainstate.(idx_of_field Domain_backtrace_pos) * 8 in
` str xzr, [{emit_reg reg_domain_state_ptr}, {emit_int offset}]\n`;
` bl {emit_symbol "caml_raise_exn"}\n`;
- `{record_frame Reg.Set.empty true i.dbg}\n`
+ `{record_frame Reg.Set.empty (Dbg_raise i.dbg)}\n`
| Lambda.Raise_reraise ->
` bl {emit_symbol "caml_raise_exn"}\n`;
- `{record_frame Reg.Set.empty true i.dbg}\n`
+ `{record_frame Reg.Set.empty (Dbg_raise i.dbg)}\n`
| Lambda.Raise_notrace ->
` mov sp, {emit_reg reg_trap_ptr}\n`;
` ldr {emit_reg reg_tmp1}, [sp, #8]\n`;
efa_data_label = (fun lbl ->
` .type {emit_label lbl}, %object\n`;
` .quad {emit_label lbl}\n`);
+ efa_8 = (fun n -> ` .byte {emit_int n}\n`);
efa_16 = (fun n -> ` .short {emit_int n}\n`);
efa_32 = (fun n -> ` .long {emit_int32 n}\n`);
efa_word = (fun n -> ` .quad {emit_int n}\n`);
if !flag then fprintf ppf "*** %s@.%a@." message Printlinear.fundecl phrase;
phrase
+let should_emit () =
+ not (should_stop_after Compiler_pass.Scheduling)
+
+let if_emit_do f x = if should_emit () then f x else ()
+let emit_begin_assembly = if_emit_do Emit.begin_assembly
+let emit_end_assembly = if_emit_do Emit.end_assembly
+let emit_data = if_emit_do Emit.data
+let emit_fundecl =
+ if_emit_do
+ (Profile.record ~accumulate:true "emit" Emit.fundecl)
+
let rec regalloc ~ppf_dump round fd =
if round > 50 then
fatal_error(fd.Mach.fun_name ^
++ pass_dump_linear_if ppf_dump dump_linear "Linearized code"
++ Profile.record ~accumulate:true "scheduling" Scheduling.fundecl
++ pass_dump_linear_if ppf_dump dump_scheduling "After instruction scheduling"
- ++ Profile.record ~accumulate:true "emit" Emit.fundecl
+ ++ emit_fundecl
let compile_phrase ~ppf_dump p =
if !dump_cmm then fprintf ppf_dump "%a@." Printcmm.phrase p;
match p with
| Cfunction fd -> compile_fundecl ~ppf_dump fd
- | Cdata dl -> Emit.data dl
+ | Cdata dl -> emit_data dl
(* For the native toplevel: generates generic functions unless
| _ -> ())
(Cmm_helpers.generic_functions true [Compilenv.current_unit_infos ()])
-let compile_unit asm_filename keep_asm obj_filename gen =
- let create_asm = keep_asm || not !Emitaux.binary_backend_available in
+let compile_unit asm_filename keep_asm
+ obj_filename gen =
+ let create_asm = should_emit () &&
+ (keep_asm || not !Emitaux.binary_backend_available) in
Emitaux.create_asm_file := create_asm;
Misc.try_finally
~exceptionally:(fun () -> remove_file obj_filename)
if create_asm then close_out !Emitaux.output_channel)
~exceptionally:(fun () ->
if create_asm && not keep_asm then remove_file asm_filename);
- let assemble_result =
- Profile.record "assemble"
- (Proc.assemble_file asm_filename) obj_filename
- in
- if assemble_result <> 0
- then raise(Error(Assembler_error asm_filename));
+ if should_emit () then begin
+ let assemble_result =
+ Profile.record "assemble"
+ (Proc.assemble_file asm_filename) obj_filename
+ in
+ if assemble_result <> 0
+ then raise(Error(Assembler_error asm_filename));
+ end;
if create_asm && not keep_asm then remove_file asm_filename
)
let end_gen_implementation ?toplevel ~ppf_dump
(clambda : Clambda.with_constants) =
- Emit.begin_assembly ();
+ emit_begin_assembly ();
clambda
++ Profile.record "cmm" Cmmgen.compunit
++ Profile.record "compile_phrases" (List.iter (compile_phrase ~ppf_dump))
if not (Primitive.native_name_is_external prim) then None
else Some (Primitive.native_name prim))
!Translmod.primitive_declarations));
- Emit.end_assembly ()
+ emit_end_assembly ()
type middle_end =
backend:(module Backend_intf.S)
| Inconsistent_interface of modname * filepath * filepath
| Inconsistent_implementation of modname * filepath * filepath
| Assembler_error of filepath
- | Linking_error
+ | Linking_error of int
| Multiple_definition of modname * filepath * filepath
| Missing_cmx of filepath * modname
then Cmi_consistbl.set crc_interfaces name crc file_name
else Cmi_consistbl.check crc_interfaces name crc file_name)
unit.ui_imports_cmi
- with Cmi_consistbl.Inconsistency(name, user, auth) ->
+ with Cmi_consistbl.Inconsistency {
+ unit_name = name;
+ inconsistent_source = user;
+ original_source = auth;
+ } ->
raise(Error(Inconsistent_interface(name, user, auth)))
end;
begin try
| Some crc ->
Cmx_consistbl.check crc_implementations name crc file_name)
unit.ui_imports_cmx
- with Cmx_consistbl.Inconsistency(name, user, auth) ->
+ with Cmx_consistbl.Inconsistency {
+ unit_name = name;
+ inconsistent_source = user;
+ original_source = auth;
+ } ->
raise(Error(Inconsistent_implementation(name, user, auth)))
end;
begin try
end
else raise(Error(Not_an_object_file file_name))
-let scan_file obj_name tolink = match read_file obj_name with
+let scan_file obj_name (tolink, objfiles) = match read_file obj_name with
| Unit (file_name,info,crc) ->
(* This is a .cmx file. It must be linked in any case. *)
remove_required info.ui_name;
List.iter (add_required file_name) info.ui_imports_cmx;
- (info, file_name, crc) :: tolink
+ ((info, file_name, crc) :: tolink, obj_name :: objfiles)
| Library (file_name,infos) ->
(* This is an archive file. Each unit contained in it will be linked
in only if needed. *)
add_ccobjs (Filename.dirname file_name) infos;
- List.fold_right
- (fun (info, crc) reqd ->
- if info.ui_force_link
- || !Clflags.link_everything
- || is_required info.ui_name
- then begin
- remove_required info.ui_name;
- List.iter (add_required (Printf.sprintf "%s(%s)"
- file_name info.ui_name))
- info.ui_imports_cmx;
- (info, file_name, crc) :: reqd
- end else
- reqd)
- infos.lib_units tolink
+ let tolink =
+ List.fold_right
+ (fun (info, crc) reqd ->
+ if info.ui_force_link
+ || !Clflags.link_everything
+ || is_required info.ui_name
+ then begin
+ remove_required info.ui_name;
+ List.iter (add_required (Printf.sprintf "%s(%s)"
+ file_name info.ui_name))
+ info.ui_imports_cmx;
+ (info, file_name, crc) :: reqd
+ end else
+ reqd)
+ infos.lib_units tolink
+ and objfiles =
+ if Config.ccomp_type = "msvc"
+ && infos.lib_units = []
+ && not (Sys.file_exists (object_file_name obj_name)) then
+ (* MSVC doesn't support empty .lib files, so there shouldn't be one
+ if the .cmxa contains no units. The file_exists check is added to
+ be ultra-defensive for the case where a user has manually added
+ things to the .lib file *)
+ objfiles
+ else
+ obj_name :: objfiles
+ in (tolink, objfiles)
(* Second pass: generate the startup file and link it with everything else *)
Emit.end_assembly ()
let call_linker_shared file_list output_name =
- if not (Ccomp.call_linker Ccomp.Dll output_name file_list "")
- then raise(Error Linking_error)
+ let exitcode = Ccomp.call_linker Ccomp.Dll output_name file_list "" in
+ if not (exitcode = 0)
+ then raise(Error(Linking_error exitcode))
let link_shared ~ppf_dump objfiles output_name =
Profile.record_call output_name (fun () ->
- let units_tolink = List.fold_right scan_file objfiles [] in
+ let units_tolink, objfiles =
+ List.fold_right scan_file objfiles ([], [])
+ in
List.iter
(fun (info, file_name, crc) -> check_consistency file_name info crc)
units_tolink;
Clflags.ccobjs := !Clflags.ccobjs @ !lib_ccobjs;
Clflags.all_ccopts := !lib_ccopts @ !Clflags.all_ccopts;
- let objfiles = List.rev (List.map object_file_name objfiles) @
+ let objfiles = List.rev_map object_file_name objfiles @
(List.rev !Clflags.ccobjs) in
let startup =
let files, c_lib =
if (not !Clflags.output_c_object) || main_dll || main_obj_runtime then
files @ (List.rev !Clflags.ccobjs) @ runtime_lib () @ libunwind,
- (if !Clflags.nopervasives || main_obj_runtime
+ (if !Clflags.nopervasives || (main_obj_runtime && not main_dll)
then "" else Config.native_c_libraries)
else
files, ""
else if !Clflags.output_c_object then Ccomp.Partial
else Ccomp.Exe
in
- if not (Ccomp.call_linker mode output_name files c_lib)
- then raise(Error Linking_error)
+ let exitcode = Ccomp.call_linker mode output_name files c_lib in
+ if not (exitcode = 0)
+ then raise(Error(Linking_error exitcode))
(* Main entry point *)
if !Clflags.nopervasives then objfiles
else if !Clflags.output_c_object then stdlib :: objfiles
else stdlib :: (objfiles @ [stdexit]) in
- let units_tolink = List.fold_right scan_file objfiles [] in
+ let units_tolink, objfiles =
+ List.fold_right scan_file objfiles ([], [])
+ in
Array.iter remove_required Runtimedef.builtin_exceptions;
begin match extract_missing_globals() with
[] -> ()
intf
| Assembler_error file ->
fprintf ppf "Error while assembling %a" Location.print_filename file
- | Linking_error ->
- fprintf ppf "Error during linking"
+ | Linking_error exitcode ->
+ fprintf ppf "Error during linking (exit code %d)" exitcode
| Multiple_definition(modname, file1, file2) ->
fprintf ppf
"@[<hov>Files %a@ and %a@ both define a module named %s@]"
| Inconsistent_interface of modname * filepath * filepath
| Inconsistent_implementation of modname * filepath * filepath
| Assembler_error of filepath
- | Linking_error
+ | Linking_error of int
| Multiple_definition of modname * filepath * filepath
| Missing_cmx of filepath * modname
List.map
(fun m -> Filename.remove_extension m.pm_file ^ Config.ext_obj)
(List.filter (fun m -> m.pm_kind <> PM_intf) members) in
- let ok =
+ let exitcode =
Ccomp.call_linker Ccomp.Partial targetobj (objtemp :: objfiles) ""
in
remove_file objtemp;
- if not ok then raise(Error Linking_error)
+ if not (exitcode = 0) then raise(Error Linking_error)
)
(* Make the .cmx file for the package *)
fixup did_fix (pc + T.instr_size instr.desc) instr.next
else
match instr.desc with
- | Lop (Ialloc { bytes = num_bytes; label_after_call_gc; }) ->
- instr.desc <- T.relax_allocation ~num_bytes ~label_after_call_gc;
+ | Lop (Ialloc { bytes = num_bytes; label_after_call_gc; dbginfo }) ->
+ instr.desc <- T.relax_allocation ~num_bytes
+ ~dbginfo ~label_after_call_gc;
fixup true (pc + T.instr_size instr.desc) instr.next
| Lop (Iintop (Icheckbound { label_after_error; })) ->
instr.desc <- T.relax_intop_checkbound ~label_after_error;
val relax_allocation
: num_bytes:int
-> label_after_call_gc:Cmm.label option
+ -> dbginfo:Debuginfo.alloc_dbginfo
-> Linear.instruction_desc
val relax_intop_checkbound
: label_after_error:Cmm.label option
| Cblockheader of nativeint * Debuginfo.t
| Cvar of Backend_var.t
| Clet of Backend_var.With_provenance.t * expression * expression
+ | Clet_mut of Backend_var.With_provenance.t * machtype
+ * expression * expression
| Cphantom_let of Backend_var.With_provenance.t
* phantom_defining_expr option * expression
| Cassign of Backend_var.t * expression
label_counter := 99
let iter_shallow_tail f = function
- | Clet(_, _, body) | Cphantom_let (_, _, body) ->
+ | Clet(_, _, body) | Cphantom_let (_, _, body) | Clet_mut(_, _, _, body) ->
f body;
true
| Cifthenelse(_cond, _ifso_dbg, ifso, _ifnot_dbg, ifnot, _dbg) ->
let rec map_tail f = function
| Clet(id, exp, body) ->
Clet(id, exp, map_tail f body)
+ | Clet_mut(id, kind, exp, body) ->
+ Clet_mut(id, kind, exp, map_tail f body)
| Cphantom_let(id, exp, body) ->
Cphantom_let (id, exp, map_tail f body)
| Cifthenelse(cond, ifso_dbg, ifso, ifnot_dbg, ifnot, dbg) ->
let map_shallow f = function
| Clet (id, e1, e2) ->
Clet (id, f e1, f e2)
+ | Clet_mut (id, kind, e1, e2) ->
+ Clet_mut (id, kind, f e1, f e2)
| Cphantom_let (id, de, e) ->
Cphantom_let (id, de, f e)
| Cassign (id, e) ->
| Cblockheader of nativeint * Debuginfo.t
| Cvar of Backend_var.t
| Clet of Backend_var.With_provenance.t * expression * expression
+ | Clet_mut of Backend_var.With_provenance.t * machtype
+ * expression * expression
| Cphantom_let of Backend_var.With_provenance.t
* phantom_defining_expr option * expression
+ (* Cassign must refer to a variable bound by Clet_mut *)
| Cassign of Backend_var.t * expression
| Ctuple of expression list
| Cop of operation * expression list * Debuginfo.t
(* 1 -> 3, 3 -> 1 *)
Cop(Csubi, [Cconst_int (4, dbg); c], dbg)
+let mk_compare_ints dbg a1 a2 =
+ match (a1,a2) with
+ | Cconst_int (c1, _), Cconst_int (c2, _) ->
+ int_const dbg (Int.compare c1 c2)
+ | Cconst_natint (c1, _), Cconst_natint (c2, _) ->
+ int_const dbg (Nativeint.compare c1 c2)
+ | Cconst_int (c1, _), Cconst_natint (c2, _) ->
+ int_const dbg Nativeint.(compare (of_int c1) c2)
+ | Cconst_natint (c1, _), Cconst_int (c2, _) ->
+ int_const dbg Nativeint.(compare c1 (of_int c2))
+ | a1, a2 -> begin
+ bind "int_cmp" a1 (fun a1 ->
+ bind "int_cmp" a2 (fun a2 ->
+ let op1 = Cop(Ccmpi(Cgt), [a1; a2], dbg) in
+ let op2 = Cop(Ccmpi(Clt), [a1; a2], dbg) in
+ tag_int(sub_int op1 op2 dbg) dbg))
+ end
+
+let mk_compare_floats dbg a1 a2 =
+ bind "float_cmp" a1 (fun a1 ->
+ bind "float_cmp" a2 (fun a2 ->
+ let op1 = Cop(Ccmpf(CFgt), [a1; a2], dbg) in
+ let op2 = Cop(Ccmpf(CFlt), [a1; a2], dbg) in
+ let op3 = Cop(Ccmpf(CFeq), [a1; a1], dbg) in
+ let op4 = Cop(Ccmpf(CFeq), [a2; a2], dbg) in
+ (* If both operands a1 and a2 are not NaN, then op3 = op4 = 1,
+ and the result is op1 - op2.
+ If at least one of the operands is NaN,
+ then op1 = op2 = 0, and the result is op3 - op4,
+ which orders NaN before other values.
+ To detect if the operand is NaN, we use the property:
+ for all x, NaN is not equal to x, even if x is NaN.
+ Therefore, op3 is 0 if and only if a1 is NaN,
+ and op4 is 0 if and only if a2 is NaN.
+ See also caml_float_compare_unboxed in runtime/floats.c *)
+ tag_int (add_int (sub_int op1 op2 dbg) (sub_int op3 op4 dbg) dbg) dbg))
let create_loop body dbg =
let cont = Lambda.next_raise_count () in
| Pbintcomp(Pint64, Lambda.Cgt) -> Pccall (default_prim "caml_greaterthan")
| Pbintcomp(Pint64, Lambda.Cle) -> Pccall (default_prim "caml_lessequal")
| Pbintcomp(Pint64, Lambda.Cge) -> Pccall (default_prim "caml_greaterequal")
+ | Pcompare_bints Pint64 -> Pccall (default_prim "caml_int64_compare")
| Pbigarrayref(_unsafe, n, Pbigarray_int64, _layout) ->
Pccall (default_prim ("caml_ba_get_" ^ Int.to_string n))
| Pbigarrayset(_unsafe, n, Pbigarray_int64, _layout) ->
let gtint = Ccmpi Cgt
type act = expression
+ type loc = Debuginfo.t
(* CR mshinwell: GPR#2294 will fix the Debuginfo here *)
let make_if cond ifso ifnot =
Cifthenelse (cond, Debuginfo.none, ifso, Debuginfo.none, ifnot,
Debuginfo.none)
- let make_switch loc arg cases actions =
- let dbg = Debuginfo.from_location loc in
+ let make_switch dbg arg cases actions =
let actions = Array.map (fun expr -> expr, dbg) actions in
make_switch arg cases actions dbg
let bind arg body = bind "switcher" arg body
(* Int switcher, arg in [low..high],
cases is list of individual cases, and is sorted by first component *)
-let transl_int_switch loc arg low high cases default = match cases with
+let transl_int_switch dbg arg low high cases default = match cases with
| [] -> assert false
| _::_ ->
let store = StoreExp.mk_store () in
bind "switcher" arg
(fun a ->
SwitcherBlocks.zyva
- loc
+ dbg
(low,high)
a
(Array.of_list inters) store)
let cconst_int i = Cconst_int (i, dbg) in
let li = V.create_local "*li*" and hi = V.create_local "*hi*"
and mi = V.create_local "*mi*" and tagged = V.create_local "*tagged*" in
- Clet (
- VP.create li, cconst_int 3,
- Clet (
- VP.create hi, Cop(Cload (Word_int, Mutable), [meths], dbg),
+ Clet_mut (
+ VP.create li, typ_int, cconst_int 3,
+ Clet_mut (
+ VP.create hi, typ_int, Cop(Cload (Word_int, Mutable), [meths], dbg),
Csequence(
ccatch
(raise_num, [],
dbg),
Clet (
VP.create tagged,
- Cop(Cadda, [lsl_const (Cvar li) log2_size_addr dbg;
+ Cop(Caddi, [lsl_const (Cvar li) log2_size_addr dbg;
cconst_int(1 - 3 * size_addr)], dbg),
Csequence(Cop (Cstore (Word_int, Assignment), [cache; Cvar tagged], dbg),
Cvar tagged)))))
(** Boolean negation *)
val mk_not : Debuginfo.t -> expression -> expression
+(** Integer and float comparison that returns int not bool *)
+val mk_compare_ints : Debuginfo.t -> expression -> expression -> expression
+val mk_compare_floats : Debuginfo.t -> expression -> expression -> expression
+
(** Loop construction (while true do expr done).
Used to be represented as Cloop. *)
val create_loop : expression -> Debuginfo.t -> expression
(** [transl_int_switch loc arg low high cases default] *)
val transl_int_switch :
- Location.t -> expression -> int -> int ->
+ Debuginfo.t -> expression -> int -> int ->
(int * expression) list -> expression -> expression
(** [transl_switch_clambda loc arg index cases] *)
val transl_switch_clambda :
- Location.t -> expression -> int array -> expression array -> expression
+ Debuginfo.t -> expression -> int array -> expression array -> expression
(** [strmatch_compile dbg arg default cases] *)
val strmatch_compile :
(* Boxed numbers *)
+let typ_of_boxed_number = function
+ | Boxed_float _ -> Cmm.typ_float
+ | Boxed_integer (Pint64, _) when size_int = 4 -> [|Int;Int|]
+ | Boxed_integer _ -> Cmm.typ_int
+
let equal_unboxed_integer ui1 ui2 =
match ui1, ui2 with
| Pnativeint, Pnativeint -> true
| Boxed_integer (bi, _) ->
unbox_int dbg bi arg
-
(* Auxiliary functions for optimizing "let" of boxed numbers (floats and
boxed integers *)
| Psetfield (_, _, _) | Psetfield_computed (_, _)
| Pfloatfield _ | Psetfloatfield (_, _) | Pduprecord (_, _)
| Praise _ | Pdivint _ | Pmodint _ | Pintcomp _ | Poffsetint _
+ | Pcompare_ints | Pcompare_floats | Pcompare_bints _
| Poffsetref _ | Pfloatcomp _ | Parraylength _
| Parrayrefu _ | Parraysetu _ | Parrayrefs _ | Parraysets _
| Pbintofint _ | Pintofbint _ | Pcvtbint (_, _) | Pnegbint _
(* Control structures *)
| Uswitch(arg, s, dbg) ->
- let loc = Debuginfo.to_location dbg in
(* As in the bytecode interpreter, only matching against constants
can be checked *)
if Array.length s.us_index_blocks = 0 then
dbg
else if Array.length s.us_index_consts = 0 then
bind "switch" (transl env arg) (fun arg ->
- transl_switch loc env (get_tag arg dbg)
+ transl_switch dbg env (get_tag arg dbg)
s.us_index_blocks s.us_actions_blocks)
else
bind "switch" (transl env arg) (fun arg ->
Cifthenelse(
Cop(Cand, [arg; Cconst_int (1, dbg)], dbg),
dbg,
- transl_switch loc env
+ transl_switch dbg env
(untag_int arg dbg) s.us_index_consts s.us_actions_consts,
dbg,
- transl_switch loc env
+ transl_switch dbg env
(get_tag arg dbg) s.us_index_blocks s.us_actions_blocks,
dbg))
| Ustringswitch(arg,sw,d) ->
let raise_num = next_raise_count () in
let id_prev = VP.create (V.create_local "*id_prev*") in
return_unit dbg
- (Clet
- (id, transl env low,
+ (Clet_mut
+ (id, typ_int, transl env low,
bind_nonvar "bound" (transl env high) (fun high ->
ccatch
(raise_num, [],
in
let env_body = add_notify_catch nfail report env in
let body = transl env_body body in
- let typ_of_bn = function
- | Boxed_float _ -> Cmm.typ_float
- | Boxed_integer (Pint64, _) when size_int = 4 -> [|Int;Int|]
- | Boxed_integer _ -> Cmm.typ_int
- in
let new_env, rewrite, ids =
List.fold_right
(fun (id, _kind, u) (env, rewrite, ids) ->
let unboxed_id = V.create_local (VP.name id) in
add_unboxed_id (VP.var id) unboxed_id bn env,
(unbox_number Debuginfo.none bn) :: rewrite,
- (VP.create unboxed_id, typ_of_bn bn) :: ids
+ (VP.create unboxed_id, typ_of_boxed_number bn) :: ids
)
ids (env, [], [])
in
| Pmakeblock (_, _, _) | Psetfield (_, _, _) | Psetfield_computed (_, _)
| Psetfloatfield (_, _) | Pduprecord (_, _) | Pccall _ | Pdivint _
| Pmodint _ | Pintcomp _ | Pfloatcomp _ | Pmakearray (_, _)
+ | Pcompare_ints | Pcompare_floats | Pcompare_bints _
| Pduparray (_, _) | Parrayrefu _ | Parraysetu _
| Parrayrefs _ | Parraysets _ | Paddbint _ | Psubbint _ | Pmulbint _
| Pdivbint _ | Pmodbint _ | Pandbint _ | Porbint _ | Pxorbint _
asr_int_caml (transl env arg1) (transl env arg2) dbg
| Pintcomp cmp ->
int_comp_caml cmp (transl env arg1) (transl env arg2) dbg
+ | Pcompare_ints ->
+ (* Compare directly on tagged ints *)
+ mk_compare_ints dbg (transl env arg1) (transl env arg2)
+ | Pcompare_bints bi ->
+ let a1 = transl_unbox_int dbg env bi arg1 in
+ let a2 = transl_unbox_int dbg env bi arg2 in
+ mk_compare_ints dbg a1 a2
+ | Pcompare_floats ->
+ let a1 = transl_unbox_float dbg env arg1 in
+ let a2 = transl_unbox_float dbg env arg2 in
+ mk_compare_floats dbg a1 a2
| Pisout ->
transl_isout (transl env arg1) (transl env arg2) dbg
(* Float operations *)
| Pbswap16 | Pint_as_pointer | Popaque | Pread_symbol _ | Pmakeblock (_, _, _)
| Pfield _ | Psetfield (_, _, _) | Pfloatfield _ | Psetfloatfield (_, _)
| Pduprecord (_, _) | Pccall _ | Praise _ | Pdivint _ | Pmodint _ | Pintcomp _
+ | Pcompare_ints | Pcompare_floats | Pcompare_bints _
| Poffsetint _ | Poffsetref _ | Pfloatcomp _ | Pmakearray (_, _)
| Pduparray (_, _) | Parraylength _ | Parrayrefu _ | Parrayrefs _
| Pbintofint _ | Pintofbint _ | Pcvtbint (_, _) | Pnegbint _ | Paddbint _
| No_unboxing | Boxed (_, true) | No_result ->
(* N.B. [body] must still be traversed even if [exp] will never return:
there may be constant closures inside that need lifting out. *)
- Clet(id, cexp, transl env body)
- | Boxed (boxed_number, _false) ->
+ begin match str, kind with
+ | Immutable, _ -> Clet(id, cexp, transl env body)
+ | Mutable, Pintval -> Clet_mut(id, typ_int, cexp, transl env body)
+ | Mutable, _ -> Clet_mut(id, typ_val, cexp, transl env body)
+ end
+ | Boxed (boxed_number, false) ->
let unboxed_id = V.create_local (VP.name id) in
- Clet(VP.create unboxed_id, unbox_number dbg boxed_number cexp,
- transl (add_unboxed_id (VP.var id) unboxed_id boxed_number env) body)
+ let v = VP.create unboxed_id in
+ let cexp = unbox_number dbg boxed_number cexp in
+ let body =
+ transl (add_unboxed_id (VP.var id) unboxed_id boxed_number env) body in
+ begin match str, boxed_number with
+ | Immutable, _ -> Clet (v, cexp, body)
+ | Mutable, bn -> Clet_mut (v, typ_of_boxed_number bn, cexp, body)
+ end
and make_catch ncatch body handler dbg = match body with
| Cexit (nexit,[]) when nexit=ncatch -> handler
then_
(* This assumes that [arg] can be safely discarded if it is not used. *)
-and transl_switch loc env arg index cases = match Array.length cases with
+and transl_switch dbg env arg index cases = match Array.length cases with
| 0 -> fatal_error "Cmmgen.transl_switch"
| 1 -> transl env cases.(0)
| _ ->
let cases = Array.map (transl env) cases in
- transl_switch_clambda loc arg index cases
+ transl_switch_clambda dbg arg index cases
and transl_letrec env bindings cont =
let dbg = Debuginfo.none in
Clet(id, op_alloc "caml_alloc_dummy_float" [int_const dbg sz],
init_blocks rem)
| (id, _exp, RHS_nonrec) :: rem ->
- Clet (id, Cconst_int (0, dbg), init_blocks rem)
+ Clet (id, Cconst_int (1, dbg), init_blocks rem)
and fill_nonrec = function
| [] -> fill_blocks bsz
| (_id, _exp,
(* Iterate over all registers preferred by the given register (transitive) *)
let iter_preferred f reg =
let rec walk r w =
- if not r.visited then begin
+ if not (Reg.is_visited r) then begin
+ Reg.mark_visited r;
f r w;
- begin match r.prefer with
- [] -> ()
- | p -> r.visited <- true;
- List.iter (fun (r1, w1) -> walk r1 (min w w1)) p;
- r.visited <- false
- end
+ List.iter (fun (r1, w1) -> walk r1 (min w w1)) r.prefer
end in
- reg.visited <- true;
List.iter (fun (r, w) -> walk r w) reg.prefer;
- reg.visited <- false in
+ Reg.clear_visited_marks () in
(* Where to start the search for a suitable register.
Used to introduce some "randomness" in the choice between registers
open Mach
+type pending_alloc =
+ { reg: Reg.t; (* register holding the result of the last allocation *)
+ dbginfos: Debuginfo.alloc_dbginfo; (* debug info for each pending alloc *)
+ totalsz: int } (* amount to be allocated in this block *)
+
type allocation_state =
No_alloc
- | Pending_alloc of
- { reg: Reg.t; (* register holding the result of the last allocation *)
- totalsz: int } (* amount to be allocated in this block *)
-
-let allocated_size = function
- No_alloc -> 0
- | Pending_alloc {totalsz; _} -> totalsz
+ | Pending_alloc of pending_alloc
let rec combine i allocstate =
match i.desc with
Iend | Ireturn | Iexit _ | Iraise _ ->
- (i, allocated_size allocstate)
- | Iop(Ialloc { bytes = sz; _ }) ->
+ (i, allocstate)
+ | Iop(Ialloc { bytes = sz; dbginfo; _ }) ->
+ assert (List.length dbginfo = 1);
begin match allocstate with
- | Pending_alloc {reg; totalsz}
- when totalsz + sz < Config.max_young_wosize * Arch.size_addr ->
- let (next, totalsz) =
+ | Pending_alloc {reg; dbginfos; totalsz}
+ when totalsz + sz <= (Config.max_young_wosize + 1) * Arch.size_addr ->
+ let (next, state) =
combine i.next
- (Pending_alloc { reg = i.res.(0); totalsz = totalsz + sz }) in
+ (Pending_alloc { reg = i.res.(0);
+ dbginfos = dbginfo @ dbginfos;
+ totalsz = totalsz + sz }) in
(instr_cons_debug (Iop(Iintop_imm(Iadd, -sz)))
[| reg |] i.res i.dbg next,
- totalsz)
+ state)
| No_alloc | Pending_alloc _ ->
- let (next, totalsz) =
+ let (next, state) =
combine i.next
- (Pending_alloc { reg = i.res.(0); totalsz = sz }) in
+ (Pending_alloc { reg = i.res.(0);
+ dbginfos = dbginfo;
+ totalsz = sz }) in
+ let totalsz, dbginfo =
+ match state with
+ | No_alloc -> assert false
+ | Pending_alloc { totalsz; dbginfos; _ } -> totalsz, dbginfos in
let next =
let offset = totalsz - sz in
if offset = 0 then next
i.res i.dbg next
in
(instr_cons_debug (Iop(Ialloc {bytes = totalsz; spacetime_index = 0;
- label_after_call_gc = None; }))
- i.arg i.res i.dbg next, allocated_size allocstate)
+ dbginfo; label_after_call_gc = None; }))
+ i.arg i.res i.dbg next, allocstate)
end
| Iop(Icall_ind _ | Icall_imm _ | Iextcall _ |
Itailcall_ind _ | Itailcall_imm _) ->
let newnext = combine_restart i.next in
(instr_cons_debug i.desc i.arg i.res i.dbg newnext,
- allocated_size allocstate)
+ allocstate)
| Iop _ ->
- let (newnext, sz) = combine i.next allocstate in
- (instr_cons_debug i.desc i.arg i.res i.dbg newnext, sz)
+ let (newnext, s') = combine i.next allocstate in
+ (instr_cons_debug i.desc i.arg i.res i.dbg newnext, s')
| Iifthenelse(test, ifso, ifnot) ->
let newifso = combine_restart ifso in
let newifnot = combine_restart ifnot in
let newnext = combine_restart i.next in
(instr_cons (Iifthenelse(test, newifso, newifnot)) i.arg i.res newnext,
- allocated_size allocstate)
+ allocstate)
| Iswitch(table, cases) ->
let newcases = Array.map combine_restart cases in
let newnext = combine_restart i.next in
(instr_cons (Iswitch(table, newcases)) i.arg i.res newnext,
- allocated_size allocstate)
+ allocstate)
| Icatch(rec_flag, handlers, body) ->
- let (newbody, sz) = combine body allocstate in
+ let (newbody, s') = combine body allocstate in
let newhandlers =
List.map (fun (io, handler) -> io, combine_restart handler) handlers in
let newnext = combine_restart i.next in
(instr_cons (Icatch(rec_flag, newhandlers, newbody))
- i.arg i.res newnext, sz)
+ i.arg i.res newnext, s')
| Itrywith(body, handler) ->
- let (newbody, sz) = combine body allocstate in
+ let (newbody, s') = combine body allocstate in
let newhandler = combine_restart handler in
let newnext = combine_restart i.next in
- (instr_cons (Itrywith(newbody, newhandler)) i.arg i.res newnext, sz)
+ (instr_cons (Itrywith(newbody, newhandler)) i.arg i.res newnext, s')
and combine_restart i =
let (newi, _) = combine i No_alloc in newi
(* Record live pointers at call points *)
+type frame_debuginfo =
+ | Dbg_alloc of Debuginfo.alloc_dbginfo
+ | Dbg_raise of Debuginfo.t
+ | Dbg_other of Debuginfo.t
+
type frame_descr =
{ fd_lbl: int; (* Return address *)
fd_frame_size: int; (* Size of stack frame *)
fd_live_offset: int list; (* Offsets/regs of live addresses *)
- fd_raise: bool; (* Is frame for a raise? *)
- fd_debuginfo: Debuginfo.t } (* Location, if any *)
+ fd_debuginfo: frame_debuginfo } (* Location, if any *)
let frame_descriptors = ref([] : frame_descr list)
-let record_frame_descr ~label ~frame_size ~live_offset ~raise_frame debuginfo =
+let record_frame_descr ~label ~frame_size ~live_offset debuginfo =
frame_descriptors :=
{ fd_lbl = label;
fd_frame_size = frame_size;
fd_live_offset = List.sort_uniq (-) live_offset;
- fd_raise = raise_frame;
fd_debuginfo = debuginfo } :: !frame_descriptors
type emit_frame_actions =
{ efa_code_label: int -> unit;
efa_data_label: int -> unit;
+ efa_8: int -> unit;
efa_16: int -> unit;
efa_32: int32 -> unit;
efa_word: int -> unit;
Hashtbl.add filenames name lbl;
lbl
in
+ let defnames = Hashtbl.create 7 in
+ let label_defname filename defname =
+ try
+ snd (Hashtbl.find defnames (filename, defname))
+ with Not_found ->
+ let file_lbl = label_filename filename in
+ let def_lbl = Cmm.new_label () in
+ Hashtbl.add defnames (filename, defname) (file_lbl, def_lbl);
+ def_lbl
+ in
let module Label_table =
Hashtbl.Make (struct
type t = bool * Debuginfo.t
end)
in
let debuginfos = Label_table.create 7 in
- let rec label_debuginfos rs rdbg =
+ let label_debuginfos rs dbg =
+ let rdbg = List.rev dbg in
let key = (rs, rdbg) in
- try fst (Label_table.find debuginfos key)
+ try Label_table.find debuginfos key
with Not_found ->
let lbl = Cmm.new_label () in
- let next =
- match rdbg with
- | [] -> assert false
- | _ :: [] -> None
- | _ :: ((_ :: _) as rdbg') -> Some (label_debuginfos false rdbg')
- in
- Label_table.add debuginfos key (lbl, next);
+ Label_table.add debuginfos key lbl;
lbl
in
- let emit_debuginfo_label rs rdbg =
- a.efa_data_label (label_debuginfos rs rdbg)
- in
let emit_frame fd =
+ assert (fd.fd_frame_size land 3 = 0);
+ let flags =
+ match fd.fd_debuginfo with
+ | Dbg_other d | Dbg_raise d ->
+ if Debuginfo.is_none d then 0 else 1
+ | Dbg_alloc dbgs ->
+ if !Clflags.debug && not Config.spacetime &&
+ List.exists (fun d ->
+ not (Debuginfo.is_none d.Debuginfo.alloc_dbg)) dbgs
+ then 3 else 2
+ in
a.efa_code_label fd.fd_lbl;
- a.efa_16 (if Debuginfo.is_none fd.fd_debuginfo
- then fd.fd_frame_size
- else fd.fd_frame_size + 1);
+ a.efa_16 (fd.fd_frame_size + flags);
a.efa_16 (List.length fd.fd_live_offset);
List.iter a.efa_16 fd.fd_live_offset;
- a.efa_align Arch.size_addr;
- match List.rev fd.fd_debuginfo with
- | [] -> ()
- | _ :: _ as rdbg -> emit_debuginfo_label fd.fd_raise rdbg
+ begin match fd.fd_debuginfo with
+ | _ when flags = 0 ->
+ ()
+ | Dbg_other dbg ->
+ a.efa_align 4;
+ a.efa_label_rel (label_debuginfos false dbg) Int32.zero
+ | Dbg_raise dbg ->
+ a.efa_align 4;
+ a.efa_label_rel (label_debuginfos true dbg) Int32.zero
+ | Dbg_alloc dbg ->
+ assert (List.length dbg < 256);
+ a.efa_8 (List.length dbg);
+ List.iter (fun Debuginfo.{alloc_words;_} ->
+ (* Possible allocations range between 2 and 257 *)
+ assert (2 <= alloc_words &&
+ alloc_words - 1 <= Config.max_young_wosize &&
+ Config.max_young_wosize <= 256);
+ a.efa_8 (alloc_words - 2)) dbg;
+ if flags = 3 then begin
+ a.efa_align 4;
+ List.iter (fun Debuginfo.{alloc_dbg; _} ->
+ if Debuginfo.is_none alloc_dbg then
+ a.efa_32 Int32.zero
+ else
+ a.efa_label_rel (label_debuginfos false alloc_dbg) Int32.zero) dbg
+ end
+ end;
+ a.efa_align Arch.size_addr
in
let emit_filename name lbl =
a.efa_def_label lbl;
- a.efa_string name;
- a.efa_align Arch.size_addr
+ a.efa_string name
+ in
+ let emit_defname (_filename, defname) (file_lbl, lbl) =
+ (* These must be 32-bit aligned, both because they contain a
+ 32-bit value, and because emit_debuginfo assumes the low 2 bits
+ of their addresses are 0. *)
+ a.efa_align 4;
+ a.efa_def_label lbl;
+ a.efa_label_rel file_lbl 0l;
+ a.efa_string defname
in
- let pack_info fd_raise d =
+ let pack_info fd_raise d has_next =
let line = min 0xFFFFF d.Debuginfo.dinfo_line
and char_start = min 0xFF d.Debuginfo.dinfo_char_start
and char_end = min 0x3FF d.Debuginfo.dinfo_char_end
- and kind = if fd_raise then 1 else 0 in
+ and kind = if fd_raise then 1 else 0
+ and has_next = if has_next then 1 else 0 in
Int64.(add (shift_left (of_int line) 44)
(add (shift_left (of_int char_start) 36)
(add (shift_left (of_int char_end) 26)
- (of_int kind))))
+ (add (shift_left (of_int kind) 1)
+ (of_int has_next)))))
in
- let emit_debuginfo (rs, rdbg) (lbl,next) =
- let d = List.hd rdbg in
- a.efa_align Arch.size_addr;
+ let emit_debuginfo (rs, rdbg) lbl =
+ (* Due to inlined functions, a single debuginfo may have multiple locations.
+ These are represented sequentially in memory (innermost frame first),
+ with the low bit of the packed debuginfo being 0 on the last entry. *)
+ a.efa_align 4;
a.efa_def_label lbl;
- let info = pack_info rs d in
- a.efa_label_rel
- (label_filename d.Debuginfo.dinfo_file)
- (Int64.to_int32 info);
- a.efa_32 (Int64.to_int32 (Int64.shift_right info 32));
- begin match next with
- | Some next -> a.efa_data_label next
- | None -> a.efa_word 0
- end
- in
+ let rec emit rs d rest =
+ let open Debuginfo in
+ let info = pack_info rs d (rest <> []) in
+ let defname = Scoped_location.string_of_scopes d.dinfo_scopes in
+ a.efa_label_rel
+ (label_defname d.dinfo_file defname)
+ (Int64.to_int32 info);
+ a.efa_32 (Int64.to_int32 (Int64.shift_right info 32));
+ match rest with
+ | [] -> ()
+ | d :: rest -> emit false d rest in
+ match rdbg with
+ | [] -> assert false
+ | d :: rest -> emit rs d rest in
a.efa_word (List.length !frame_descriptors);
List.iter emit_frame !frame_descriptors;
Label_table.iter emit_debuginfo debuginfos;
Hashtbl.iter emit_filename filenames;
+ Hashtbl.iter emit_defname defnames;
+ a.efa_align Arch.size_addr;
frame_descriptors := []
(* Detection of functions that can be duplicated between a DLL and
(file_num:int -> file_name:string -> unit) ->
(file_num:int -> line:int -> col:int -> unit) -> unit
+type frame_debuginfo =
+ | Dbg_alloc of Debuginfo.alloc_dbginfo
+ | Dbg_raise of Debuginfo.t
+ | Dbg_other of Debuginfo.t
+
val record_frame_descr :
label:int -> (* Return address *)
frame_size:int -> (* Size of stack frame *)
live_offset:int list -> (* Offsets/regs of live addresses *)
- raise_frame:bool -> (* Is frame for a raise? *)
- Debuginfo.t -> (* Location, if any *)
+ frame_debuginfo -> (* Location, if any *)
unit
type emit_frame_actions =
{ efa_code_label: int -> unit;
efa_data_label: int -> unit;
+ efa_8: int -> unit;
efa_16: int -> unit;
efa_32: int32 -> unit;
efa_word: int -> unit;
(* Record live pointers at call points *)
-let record_frame_label ?label live raise_ dbg =
+let record_frame_label ?label live dbg =
let lbl =
match label with
| None -> new_label()
| _ -> ())
live;
record_frame_descr ~label:lbl ~frame_size:(frame_size())
- ~live_offset:!live_offset ~raise_frame:raise_ dbg;
+ ~live_offset:!live_offset dbg;
lbl
-let record_frame ?label live raise_ dbg =
- let lbl = record_frame_label ?label live raise_ dbg in
+let record_frame ?label live dbg =
+ let lbl = record_frame_label ?label live dbg in
def_label lbl
(* Record calls to the GC -- we've moved them out of the way *)
let bound_error_label ?label dbg =
if !Clflags.debug then begin
let lbl_bound_error = new_label() in
- let lbl_frame = record_frame_label ?label Reg.Set.empty false dbg in
+ let lbl_frame = record_frame_label ?label Reg.Set.empty (Dbg_other dbg) in
bound_error_sites :=
{ bd_lbl = lbl_bound_error; bd_frame = lbl_frame } :: !bound_error_sites;
lbl_bound_error
I.mov (immsym s) (reg i.res.(0))
| Lop(Icall_ind { label_after; }) ->
I.call (reg i.arg.(0));
- record_frame i.live false i.dbg ~label:label_after
+ record_frame i.live (Dbg_other i.dbg) ~label:label_after
| Lop(Icall_imm { func; label_after; }) ->
add_used_symbol func;
emit_call func;
- record_frame i.live false i.dbg ~label:label_after
+ record_frame i.live (Dbg_other i.dbg) ~label:label_after
| Lop(Itailcall_ind { label_after = _; }) ->
output_epilogue begin fun () ->
I.jmp (reg i.arg.(0))
if alloc then begin
I.mov (immsym func) eax;
emit_call "caml_c_call";
- record_frame i.live false i.dbg ~label:label_after
+ record_frame i.live (Dbg_other i.dbg) ~label:label_after
end else begin
emit_call func
end
I.fstp (addressing addr REAL8 i 1)
end
end
- | Lop(Ialloc { bytes = n; label_after_call_gc; }) ->
+ | Lop(Ialloc { bytes = n; label_after_call_gc; dbginfo }) ->
if !fastcode_flag then begin
- let lbl_redo = new_label() in
- def_label lbl_redo;
load_domain_state ebx;
I.mov (domain_field Domain_young_ptr RBX) eax;
I.sub (int n) eax;
+ I.mov eax (domain_field Domain_young_ptr RBX);
I.cmp (domain_field Domain_young_limit RBX) eax;
let lbl_call_gc = new_label() in
- let lbl_frame = record_frame_label i.live false Debuginfo.none in
+ let lbl_frame =
+ record_frame_label ?label:label_after_call_gc
+ i.live (Dbg_alloc dbginfo) in
I.jb (label lbl_call_gc);
- I.mov eax (domain_field Domain_young_ptr RBX);
+ let lbl_after_alloc = new_label() in
+ def_label lbl_after_alloc;
I.lea (mem32 NONE 4 RAX) (reg i.res.(0));
call_gc_sites :=
{ gc_lbl = lbl_call_gc;
- gc_return_lbl = lbl_redo;
+ gc_return_lbl = lbl_after_alloc;
gc_frame = lbl_frame } :: !call_gc_sites
end else begin
begin match n with
emit_call "caml_allocN"
end;
let label =
- record_frame_label ?label:label_after_call_gc i.live false
- Debuginfo.none
+ record_frame_label ?label:label_after_call_gc
+ i.live (Dbg_alloc dbginfo)
in
def_label label;
I.lea (mem32 NONE 4 RAX) (reg i.res.(0))
load_domain_state ebx;
I.mov (int 0) (domain_field Domain_backtrace_pos RBX);
emit_call "caml_raise_exn";
- record_frame Reg.Set.empty true i.dbg
+ record_frame Reg.Set.empty (Dbg_raise i.dbg)
| Lambda.Raise_reraise ->
emit_call "caml_raise_exn";
- record_frame Reg.Set.empty true i.dbg
+ record_frame Reg.Set.empty (Dbg_raise i.dbg)
| Lambda.Raise_notrace ->
load_domain_state ebx;
I.mov (domain_field Domain_exception_pointer RBX) esp;
emit_frames
{ efa_code_label = (fun l -> D.long (ConstLabel (emit_label l)));
efa_data_label = (fun l -> D.long (ConstLabel (emit_label l)));
+ efa_8 = (fun n -> D.byte (const n));
efa_16 = (fun n -> D.word (const n));
efa_32 = (fun n -> D.long (const_32 n));
efa_word = (fun n -> D.long (const n));
| Iload of Cmm.memory_chunk * Arch.addressing_mode
| Istore of Cmm.memory_chunk * Arch.addressing_mode * bool
| Ialloc of { bytes : int; label_after_call_gc : label option;
- spacetime_index : int; }
+ dbginfo : Debuginfo.alloc_dbginfo; spacetime_index : int; }
| Iintop of integer_operation
| Iintop_imm of integer_operation * int
| Inegf | Iabsf | Iaddf | Isubf | Imulf | Idivf
| Istore of Cmm.memory_chunk * Arch.addressing_mode * bool
(* false = initialization, true = assignment *)
| Ialloc of { bytes : int; label_after_call_gc : label option;
- spacetime_index : int; }
+ dbginfo : Debuginfo.alloc_dbginfo; spacetime_index : int; }
(** For Spacetime only, Ialloc instructions take one argument, being the
pointer to the trie node for the current function. *)
| Iintop of integer_operation
(* Machine-specific command-line options *)
-let big_toc = ref false
+let big_toc = ref true
let command_line_options = [
"-flarge-toc", Arg.Set big_toc,
- " Support TOC (table of contents) greater than 64 kbytes"
+ " Support TOC (table of contents) greater than 64 kbytes (default)";
+ "-fsmall-toc", Arg.Clear big_toc,
+ " TOC (table of contents) is limited to 64 kbytes"
]
(* Specific operations *)
Imultaddf (* multiply and add *)
| Imultsubf (* multiply and subtract *)
| Ialloc_far of (* allocation in large functions *)
- { bytes : int; label_after_call_gc : int (*Cmm.label*) option; }
+ { bytes : int; label_after_call_gc : int (*Cmm.label*) option;
+ dbginfo : Debuginfo.alloc_dbginfo }
(* note: we avoid introducing a dependency to Cmm since this dep
is not detected when "make depend" is run under amd64 *)
(* Record live pointers at call points *)
-let record_frame ?label live raise_ dbg =
+let record_frame ?label live dbg =
let lbl =
match label with
| None -> new_label()
| _ -> ())
live;
record_frame_descr ~label:lbl ~frame_size:(frame_size())
- ~live_offset:!live_offset ~raise_frame:raise_ dbg;
+ ~live_offset:!live_offset dbg;
`{emit_label lbl}:\n`
(* Record floating-point literals (for PPC32) *)
let function_name = ref ""
(* Entry point for tail recursive calls *)
let tailrec_entry_point = ref 0
-
-module IntSet = Stdlib.Set.Make(Stdlib.Int)
-module IntMap = Stdlib.Map.Make(Stdlib.Int)
-
-(* Labels of glue code for calling the GC.
- There is one label per size allocated. *)
-let call_gc_labels : label IntMap.t ref = ref IntMap.empty
- (* size -> label *)
-
-(* Return the label of the call GC point for the given size *)
-
-let label_for_call_gc ?label_after_call_gc sz =
- match IntMap.find_opt sz !call_gc_labels with
- | Some lbl -> lbl
- | None ->
- let lbl =
- match label_after_call_gc with Some l -> l | None -> new_label() in
- call_gc_labels := IntMap.add sz lbl !call_gc_labels;
- lbl
-
-(* Number of call GC points *)
-
-let num_call_gc instr =
- let rec loop i cg =
- match i.desc with
- | Lend -> IntSet.cardinal cg
- | Lop (Ialloc {bytes = sz}) -> loop i.next (IntSet.add sz cg)
- (* The following should never be seen, since this function is run
- before branch relaxation. *)
- | Lop (Ispecific (Ialloc_far _)) -> assert false
- | _ -> loop i.next cg
- in loop instr IntSet.empty
+(* Label of glue code for calling the GC *)
+let call_gc_label = ref 0
(* Relaxation of branches that exceed the span of a relative branch. *)
| Lpoptrap -> 2
| Lraise _ -> 6
- let relax_allocation ~num_bytes:bytes ~label_after_call_gc =
- Lop (Ispecific (Ialloc_far { bytes; label_after_call_gc; }))
+ let relax_allocation ~num_bytes:bytes ~label_after_call_gc ~dbginfo =
+ Lop (Ispecific (Ialloc_far { bytes; label_after_call_gc; dbginfo }))
(* [classify_addr], above, never identifies these instructions as needing
relaxing. As such, these functions should never be called. *)
| ELF32 ->
` mtctr {emit_reg i.arg.(0)}\n`;
` bctrl\n`;
- record_frame i.live false i.dbg ~label:label_after
+ record_frame i.live (Dbg_other i.dbg) ~label:label_after
| ELF64v1 ->
` ld 0, 0({emit_reg i.arg.(0)})\n`; (* code pointer *)
` mtctr 0\n`;
` ld 2, 8({emit_reg i.arg.(0)})\n`; (* TOC for callee *)
` bctrl\n`;
- record_frame i.live false i.dbg ~label:label_after;
+ record_frame i.live (Dbg_other i.dbg) ~label:label_after;
emit_reload_toc()
| ELF64v2 ->
` mtctr {emit_reg i.arg.(0)}\n`;
` mr 12, {emit_reg i.arg.(0)}\n`; (* addr of fn in r12 *)
` bctrl\n`;
- record_frame i.live false i.dbg ~label:label_after;
+ record_frame i.live (Dbg_other i.dbg) ~label:label_after;
emit_reload_toc()
end
| Lop(Icall_imm { func; label_after; }) ->
begin match abi with
| ELF32 ->
emit_call func;
- record_frame i.live false i.dbg ~label:label_after
+ record_frame i.live (Dbg_other i.dbg) ~label:label_after
| ELF64v1 | ELF64v2 ->
(* For PPC64, we cannot just emit a "bl s; nop" sequence, because
of the following scenario:
Cost: 3 instructions if same TOC, 7 if different TOC.
Let's try option 2. *)
emit_call func;
- record_frame i.live false i.dbg ~label:label_after;
+ record_frame i.live (Dbg_other i.dbg) ~label:label_after;
` nop\n`;
emit_reload_toc()
end
` addis 25, 0, {emit_upper emit_symbol func}\n`;
` addi 25, 25, {emit_lower emit_symbol func}\n`;
emit_call "caml_c_call";
- record_frame i.live false i.dbg
+ record_frame i.live (Dbg_other i.dbg)
| ELF64v1 | ELF64v2 ->
emit_tocload emit_gpr 25 (TocSym func);
emit_call "caml_c_call";
- record_frame i.live false i.dbg;
+ record_frame i.live (Dbg_other i.dbg);
` nop\n`
end
| Lop(Istackoffset n) ->
| Single -> "stfs"
| Double | Double_u -> "stfd" in
emit_load_store storeinstr addr i.arg 1 i.arg.(0)
- | Lop(Ialloc { bytes = n; label_after_call_gc; }) ->
- let call_gc_lbl = label_for_call_gc ?label_after_call_gc n in
+ | Lop(Ialloc { bytes = n; label_after_call_gc; dbginfo }) ->
+ if !call_gc_label = 0 then begin
+ match label_after_call_gc with
+ | None -> call_gc_label := new_label ()
+ | Some label -> call_gc_label := label
+ end;
` addi 31, 31, {emit_int(-n)}\n`;
` {emit_string cmplg} 31, 30\n`;
+ ` bltl {emit_label !call_gc_label}\n`;
+ record_frame i.live (Dbg_alloc dbginfo);
` addi {emit_reg i.res.(0)}, 31, {emit_int size_addr}\n`;
- ` bltl {emit_label call_gc_lbl}\n`;
- (* Exactly 4 instructions after the beginning of the alloc sequence *)
- record_frame i.live false Debuginfo.none
- | Lop(Ispecific(Ialloc_far { bytes = n; label_after_call_gc; })) ->
- let call_gc_lbl = label_for_call_gc ?label_after_call_gc n in
+ | Lop(Ispecific(Ialloc_far { bytes = n; label_after_call_gc; dbginfo })) ->
+ if !call_gc_label = 0 then begin
+ match label_after_call_gc with
+ | None -> call_gc_label := new_label ()
+ | Some label -> call_gc_label := label
+ end;
let lbl = new_label() in
` addi 31, 31, {emit_int(-n)}\n`;
` {emit_string cmplg} 31, 30\n`;
` bge {emit_label lbl}\n`;
- ` bl {emit_label call_gc_lbl}\n`;
- (* Exactly 4 instructions after the beginning of the alloc sequence *)
- record_frame i.live false Debuginfo.none;
+ ` bl {emit_label !call_gc_label}\n`;
+ record_frame i.live (Dbg_alloc dbginfo);
`{emit_label lbl}: addi {emit_reg i.res.(0)}, 31, {emit_int size_addr}\n`
| Lop(Iintop Isub) -> (* subfc has swapped arguments *)
` subfc {emit_reg i.res.(0)}, {emit_reg i.arg.(1)}, {emit_reg i.arg.(0)}\n`
end
| Lop(Iintop (Icheckbound { label_after_error; })) ->
if !Clflags.debug then
- record_frame Reg.Set.empty false i.dbg ?label:label_after_error;
+ record_frame Reg.Set.empty (Dbg_other i.dbg) ?label:label_after_error;
` {emit_string tglle} {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`
| Lop(Iintop op) ->
let instr = name_for_intop op in
end
| Lop(Iintop_imm(Icheckbound { label_after_error; }, n)) ->
if !Clflags.debug then
- record_frame Reg.Set.empty false i.dbg ?label:label_after_error;
+ record_frame Reg.Set.empty (Dbg_other i.dbg) ?label:label_after_error;
` {emit_string tglle}i {emit_reg i.arg.(0)}, {emit_int n}\n`
| Lop(Iintop_imm(op, n)) ->
let instr = name_for_intop_imm op in
| _ -> ` std 0, {emit_int (backtrace_pos * 8)}(28)\n`
end;
emit_call "caml_raise_exn";
- record_frame Reg.Set.empty true i.dbg;
+ record_frame Reg.Set.empty (Dbg_raise i.dbg);
emit_call_nop()
| Lambda.Raise_reraise ->
emit_call "caml_raise_exn";
- record_frame Reg.Set.empty true i.dbg;
+ record_frame Reg.Set.empty (Dbg_raise i.dbg);
emit_call_nop()
| Lambda.Raise_notrace ->
` {emit_string lg} 0, {emit_int trap_handler_offset}(29)\n`;
function_name := fundecl.fun_name;
tailrec_entry_point := fundecl.fun_tailrec_entry_point_label;
stack_offset := 0;
- call_gc_labels := IntMap.empty;
+ call_gc_label := 0;
float_literals := [];
jumptables := []; jumptables_lbl := -1;
for i = 0 to Proc.num_register_classes - 1 do
end;
emit_debug_info fundecl.fun_dbg;
cfi_startproc();
- let num_call_gc = num_call_gc fundecl.fun_body in
- let max_out_of_line_code_offset = max (num_call_gc - 1) 0 in
- BR.relax fundecl.fun_body ~max_out_of_line_code_offset;
+ (* On this target, there is at most one "out of line" code block per
+ function: a single "call GC" point. It comes immediately after the
+ function's body. *)
+ BR.relax fundecl.fun_body ~max_out_of_line_code_offset:0;
emit_all fundecl.fun_body;
(* Emit the glue code to call the GC *)
- assert (IntMap.cardinal !call_gc_labels = num_call_gc);
- if num_call_gc > 0 then begin
- (* Replace sizes by deltas with next size *)
- let rec delta_encode = function
- | (sz1, lbl1) :: ((sz2, _) :: _ as l) ->
- (sz1 - sz2, lbl1) :: delta_encode l
- | ([] | [(_,_)]) as l -> l in
- (* Enumerate the GC call points by decreasing size. This is not
- necessary for correctness, but it is nice for two reasons:
- 1- all deltas are positive, making the generated code
- easier to read, and
- 2- smaller allocation sizes, which are more frequent, execute
- fewer instructions before calling the GC. *)
- let delta_lbl_list =
- delta_encode (List.rev (IntMap.bindings !call_gc_labels)) in
- List.iter
- (fun (delta, lbl) ->
- `{emit_label lbl}: addi 31, 31, {emit_int delta}\n`)
- delta_lbl_list;
+ if !call_gc_label > 0 then begin
+ `{emit_label !call_gc_label}:\n`;
match abi with
| ELF32 ->
` b {emit_symbol "caml_call_gc"}\n`
(fun l -> ` {emit_string datag} {emit_label l}\n`);
efa_data_label =
(fun l -> ` {emit_string datag} {emit_label l}\n`);
+ efa_8 = (fun n -> ` .byte {emit_int n}\n`);
efa_16 = (fun n -> ` .short {emit_int n}\n`);
efa_32 = (fun n -> ` .long {emit_int32 n}\n`);
efa_word = (fun n -> ` {emit_string datag} {emit_int n}\n`);
| None -> Format.pp_print_string ppf "()"
| Some defining_expr -> phantom_defining_expr ppf defining_expr
+let location d =
+ if not !Clflags.locations then ""
+ else Debuginfo.to_string d
+
let operation d = function
- | Capply _ty -> "app" ^ Debuginfo.to_string d
+ | Capply _ty -> "app" ^ location d
| Cextcall(lbl, _ty, _alloc, _) ->
- Printf.sprintf "extcall \"%s\"%s" lbl (Debuginfo.to_string d)
+ Printf.sprintf "extcall \"%s\"%s" lbl (location d)
| Cload (c, Asttypes.Immutable) -> Printf.sprintf "load %s" (chunk c)
| Cload (c, Asttypes.Mutable) -> Printf.sprintf "load_mut %s" (chunk c)
- | Calloc -> "alloc" ^ Debuginfo.to_string d
+ | Calloc -> "alloc" ^ location d
| Cstore (c, init) ->
let init =
match init with
| Cfloatofint -> "floatofint"
| Cintoffloat -> "intoffloat"
| Ccmpf c -> Printf.sprintf "%sf" (float_comparison c)
- | Craise k -> Lambda.raise_kind k ^ Debuginfo.to_string d
- | Ccheckbound -> "checkbound" ^ Debuginfo.to_string d
+ | Craise k -> Lambda.raise_kind k ^ location d
+ | Ccheckbound -> "checkbound" ^ location d
let rec expr ppf = function
| Cconst_int (n, _dbg) -> fprintf ppf "%i" n
fprintf ppf "%s" (Nativeint.to_string n)
| Cblockheader(n, d) ->
fprintf ppf "block-hdr(%s)%s"
- (Nativeint.to_string n) (Debuginfo.to_string d)
+ (Nativeint.to_string n) (location d)
| Cconst_float (n, _dbg) -> fprintf ppf "%F" n
| Cconst_symbol (s, _dbg) -> fprintf ppf "\"%s\"" s
| Cconst_pointer (n, _dbg) -> fprintf ppf "%ia" n
fprintf ppf
"@[<2>(let@ @[<2>%a@ %a@]@ %a)@]"
VP.print id expr def sequence body
+ | Clet_mut(id, kind, def, body) ->
+ fprintf ppf
+ "@[<2>(let_mut@ @[<2>%a: %a@ %a@]@ %a)@]"
+ VP.print id machtype kind expr def sequence body
| Cphantom_let(var, def, (Cphantom_let(_, _, _) as body)) ->
let print_binding var ppf def =
fprintf ppf "@[<2>%a@ %a@]" VP.print var
fprintf ppf "%a: %a" VP.print id machtype ty)
cases in
fprintf ppf "@[<1>(function%s %s@;<1 4>@[<1>(%a)@]@ @[%a@])@]@."
- (Debuginfo.to_string f.fun_dbg) f.fun_name
+ (location f.fun_dbg) f.fun_name
print_cases f.fun_args sequence f.fun_body
let data_item ppf = function
| Lraise k ->
fprintf ppf "%s %a" (Lambda.raise_kind k) reg i.arg.(0)
end;
- if not (Debuginfo.is_none i.dbg) then
+ if not (Debuginfo.is_none i.dbg) && !Clflags.locations then
fprintf ppf " %s" (Debuginfo.to_string i.dbg)
let rec all_instr ppf i =
let fundecl ppf f =
let dbg =
- if Debuginfo.is_none f.fun_dbg then
+ if Debuginfo.is_none f.fun_dbg || not !Clflags.locations then
""
else
" " ^ Debuginfo.to_string f.fun_dbg in
| Iraise k ->
fprintf ppf "%s %a" (Lambda.raise_kind k) reg i.arg.(0)
end;
- if not (Debuginfo.is_none i.dbg) then
+ if not (Debuginfo.is_none i.dbg) && !Clflags.locations then
fprintf ppf "%s" (Debuginfo.to_string i.dbg);
begin match i.next.desc with
Iend -> ()
let fundecl ppf f =
let dbg =
- if Debuginfo.is_none f.fun_dbg then
+ if Debuginfo.is_none f.fun_dbg || not !Clflags.locations then
""
else
" " ^ Debuginfo.to_string f.fun_dbg in
type t =
{ mutable raw_name: Raw_name.t;
stamp: int;
- mutable typ: Cmm.machtype_component;
+ typ: Cmm.machtype_component;
mutable loc: location;
mutable spill: bool;
mutable part: int option;
mutable prefer: (t * int) list;
mutable degree: int;
mutable spill_cost: int;
- mutable visited: bool }
+ mutable visited: int }
and location =
Unknown
let dummy =
{ raw_name = Raw_name.Anon; stamp = 0; typ = Int; loc = Unknown;
spill = false; interf = []; prefer = []; degree = 0; spill_cost = 0;
- visited = false; part = None;
+ visited = 0; part = None;
}
let currstamp = ref 0
let reg_list = ref([] : t list)
+let hw_reg_list = ref ([] : t list)
+
+let visit_generation = ref 1
+
+(* Any visited value not equal to !visit_generation counts as "unvisited" *)
+let unvisited = 0
+
+let mark_visited r =
+ r.visited <- !visit_generation
+
+let is_visited r =
+ r.visited = !visit_generation
+
+let clear_visited_marks () =
+ incr visit_generation
+
let create ty =
let r = { raw_name = Raw_name.Anon; stamp = !currstamp; typ = ty;
loc = Unknown; spill = false; interf = []; prefer = []; degree = 0;
- spill_cost = 0; visited = false; part = None; } in
+ spill_cost = 0; visited = unvisited; part = None; } in
reg_list := r :: !reg_list;
incr currstamp;
r
let at_location ty loc =
let r = { raw_name = Raw_name.R; stamp = !currstamp; typ = ty; loc;
spill = false; interf = []; prefer = []; degree = 0;
- spill_cost = 0; visited = false; part = None; } in
+ spill_cost = 0; visited = unvisited; part = None; } in
+ hw_reg_list := r :: !hw_reg_list;
incr currstamp;
r
all hard pseudo-registers that have been allocated by Proc, so
remember it and use it as the base stamp for allocating
soft pseudo-registers *)
- if !first_virtual_reg_stamp = -1 then first_virtual_reg_stamp := !currstamp;
+ if !first_virtual_reg_stamp = -1 then begin
+ first_virtual_reg_stamp := !currstamp;
+ assert (!reg_list = []) (* Only hard regs created before now *)
+ end;
currstamp := !first_virtual_reg_stamp;
- reg_list := []
+ reg_list := [];
+ visit_generation := 1;
+ !hw_reg_list |> List.iter (fun r ->
+ r.visited <- unvisited)
let all_registers() = !reg_list
let num_registers() = !currstamp
type t =
{ mutable raw_name: Raw_name.t; (* Name *)
stamp: int; (* Unique stamp *)
- mutable typ: Cmm.machtype_component;(* Type of contents *)
+ typ: Cmm.machtype_component; (* Type of contents *)
mutable loc: location; (* Actual location *)
mutable spill: bool; (* "true" to force stack allocation *)
mutable part: int option; (* Zero-based index of part of value *)
mutable prefer: (t * int) list; (* Preferences for other regs *)
mutable degree: int; (* Number of other regs live sim. *)
mutable spill_cost: int; (* Estimate of spilling cost *)
- mutable visited: bool } (* For graph walks *)
+ mutable visited: int } (* For graph walks *)
and location =
Unknown
val all_registers: unit -> t list
val num_registers: unit -> int
val reinit: unit -> unit
+
+val mark_visited : t -> unit
+val is_visited : t -> bool
+val clear_visited_marks : unit -> unit
--- /dev/null
+(**************************************************************************)
+(* *)
+(* OCaml *)
+(* *)
+(* Nicolas Ojeda Bar <n.oje.bar@gmail.com> *)
+(* *)
+(* Copyright 2016 Institut National de Recherche en Informatique et *)
+(* en Automatique. *)
+(* *)
+(* All rights reserved. This file is distributed under the terms of *)
+(* the GNU Lesser General Public License version 2.1, with the *)
+(* special exception on linking described in the file LICENSE. *)
+(* *)
+(**************************************************************************)
+
+(* CSE for the RISC-V *)
+
+open Arch
+open Mach
+open CSEgen
+
+class cse = object (_self)
+
+inherit cse_generic as super
+
+method! class_of_operation op =
+ match op with
+ | Ispecific(Imultaddf _ | Imultsubf _) -> Op_pure
+ | _ -> super#class_of_operation op
+
+method! is_cheap_operation op =
+ match op with
+ | Iconst_int n -> n <= 0x7FFn && n >= -0x800n
+ | _ -> false
+
+end
+
+let fundecl f =
+ (new cse)#fundecl f
--- /dev/null
+# Supported platforms
+
+RISC-V in 64-bit mode, general variant, a.k.a `RV64G`.
+
+Debian architecture name: `riscv64`
+
+# Reference documents
+
+* Instruction set specification:
+ - https://riscv.org/specifications/isa-spec-pdf/
+ - https://rv8.io/isa
+
+* ELF ABI specification:
+ - https://github.com/riscv/riscv-elf-psabi-doc/blob/master/riscv-elf.md
+
+* Assembly language manual
+ - https://github.com/riscv/riscv-asm-manual/blob/master/riscv-asm.md
+ - https://rv8.io/asm
--- /dev/null
+(**************************************************************************)
+(* *)
+(* OCaml *)
+(* *)
+(* Nicolas Ojeda Bar <n.oje.bar@gmail.com> *)
+(* *)
+(* Copyright 2016 Institut National de Recherche en Informatique et *)
+(* en Automatique. *)
+(* *)
+(* All rights reserved. This file is distributed under the terms of *)
+(* the GNU Lesser General Public License version 2.1, with the *)
+(* special exception on linking described in the file LICENSE. *)
+(* *)
+(**************************************************************************)
+
+(* Specific operations for the RISC-V processor *)
+
+open Format
+
+(* Machine-specific command-line options *)
+
+let command_line_options = []
+
+(* Specific operations *)
+
+type specific_operation =
+ | Imultaddf of bool (* multiply, optionally negate, and add *)
+ | Imultsubf of bool (* multiply, optionally negate, and subtract *)
+
+let spacetime_node_hole_pointer_is_live_before = function
+ | Imultaddf _ | Imultsubf _ -> false
+
+(* Addressing modes *)
+
+type addressing_mode =
+ | Iindexed of int (* reg + displ *)
+
+let is_immediate n =
+ (n <= 0x7FF) && (n >= -0x800)
+
+(* Sizes, endianness *)
+
+let big_endian = false
+
+let size_addr = 8
+let size_int = size_addr
+let size_float = 8
+
+let allow_unaligned_access = false
+
+(* Behavior of division *)
+
+let division_crashes_on_overflow = false
+
+(* Operations on addressing modes *)
+
+let identity_addressing = Iindexed 0
+
+let offset_addressing addr delta =
+ match addr with
+ | Iindexed n -> Iindexed(n + delta)
+
+let num_args_addressing = function
+ | Iindexed _ -> 1
+
+(* Printing operations and addressing modes *)
+
+let print_addressing printreg addr ppf arg =
+ match addr with
+ | Iindexed n ->
+ let idx = if n <> 0 then Printf.sprintf " + %i" n else "" in
+ fprintf ppf "%a%s" printreg arg.(0) idx
+
+let print_specific_operation printreg op ppf arg =
+ match op with
+ | Imultaddf false ->
+ fprintf ppf "%a *f %a +f %a"
+ printreg arg.(0) printreg arg.(1) printreg arg.(2)
+ | Imultaddf true ->
+ fprintf ppf "-f (%a *f %a +f %a)"
+ printreg arg.(0) printreg arg.(1) printreg arg.(2)
+ | Imultsubf false ->
+ fprintf ppf "%a *f %a -f %a"
+ printreg arg.(0) printreg arg.(1) printreg arg.(2)
+ | Imultsubf true ->
+ fprintf ppf "-f (%a *f %a -f %a)"
+ printreg arg.(0) printreg arg.(1) printreg arg.(2)
--- /dev/null
+# 2 "asmcomp/riscv/emit.mlp"
+(**************************************************************************)
+(* *)
+(* OCaml *)
+(* *)
+(* Nicolas Ojeda Bar <n.oje.bar@gmail.com> *)
+(* *)
+(* Copyright 2016 Institut National de Recherche en Informatique et *)
+(* en Automatique. *)
+(* *)
+(* All rights reserved. This file is distributed under the terms of *)
+(* the GNU Lesser General Public License version 2.1, with the *)
+(* special exception on linking described in the file LICENSE. *)
+(* *)
+(**************************************************************************)
+
+(* Emission of RISC-V assembly code *)
+
+open Cmm
+open Arch
+open Proc
+open Reg
+open Mach
+open Linear
+open Emitaux
+
+(* Layout of the stack. The stack is kept 16-aligned. *)
+
+let stack_offset = ref 0
+
+let num_stack_slots = Array.make Proc.num_register_classes 0
+
+let prologue_required = ref false
+
+let contains_calls = ref false
+
+let frame_size () =
+ let size =
+ !stack_offset + (* Trap frame, outgoing parameters *)
+ size_int * num_stack_slots.(0) + (* Local int variables *)
+ size_float * num_stack_slots.(1) + (* Local float variables *)
+ (if !contains_calls then size_addr else 0) in (* The return address *)
+ Misc.align size 16
+
+let slot_offset loc cls =
+ match loc with
+ | Local n ->
+ if cls = 0
+ then !stack_offset + num_stack_slots.(1) * size_float + n * size_int
+ else !stack_offset + n * size_float
+ | Incoming n -> frame_size() + n
+ | Outgoing n -> n
+
+(* Output a symbol *)
+
+let emit_symbol s =
+ emit_symbol '$' s
+
+let emit_jump op s =
+ if !Clflags.dlcode || !Clflags.pic_code
+ then `{emit_string op} {emit_symbol s}@plt`
+ else `{emit_string op} {emit_symbol s}`
+
+let emit_call = emit_jump "call"
+let emit_tail = emit_jump "tail"
+
+(* Output a label *)
+
+let emit_label lbl =
+ emit_string ".L"; emit_int lbl
+
+(* Section switching *)
+
+let data_space =
+ ".section .data"
+
+let code_space =
+ ".section .text"
+
+let rodata_space =
+ ".section .rodata"
+
+(* Names for special regs *)
+
+let reg_tmp = phys_reg 22
+let reg_t2 = phys_reg 16
+let reg_domain_state_ptr = phys_reg 23
+let reg_trap = phys_reg 24
+let reg_alloc_ptr = phys_reg 25
+let reg_alloc_lim = phys_reg 26
+
+(* Output a pseudo-register *)
+
+let reg_name = function
+ | {loc = Reg r} -> register_name r
+ | _ -> Misc.fatal_error "Emit.reg_name"
+
+let emit_reg r =
+ emit_string (reg_name r)
+
+(* Adjust sp by the given byte amount *)
+
+let emit_stack_adjustment = function
+ | 0 -> ()
+ | n when is_immediate n ->
+ ` addi sp, sp, {emit_int n}\n`
+ | n ->
+ ` li {emit_reg reg_tmp}, {emit_int n}\n`;
+ ` add sp, sp, {emit_reg reg_tmp}\n`
+
+let emit_mem_op op src ofs =
+ if is_immediate ofs then
+ ` {emit_string op} {emit_string src}, {emit_int ofs}(sp)\n`
+ else begin
+ ` li {emit_reg reg_tmp}, {emit_int ofs}\n`;
+ ` add {emit_reg reg_tmp}, sp, {emit_reg reg_tmp}\n`;
+ ` {emit_string op} {emit_string src}, 0({emit_reg reg_tmp})\n`
+ end
+
+let emit_store src ofs =
+ emit_mem_op "sd" src ofs
+
+let emit_load dst ofs =
+ emit_mem_op "ld" dst ofs
+
+let reload_ra n =
+ emit_load "ra" (n - size_addr)
+
+let store_ra n =
+ emit_store "ra" (n - size_addr)
+
+let emit_store src ofs =
+ emit_store (reg_name src) ofs
+
+let emit_load dst ofs =
+ emit_load (reg_name dst) ofs
+
+let emit_float_load dst ofs =
+ emit_mem_op "fld" (reg_name dst) ofs
+
+let emit_float_store src ofs =
+ emit_mem_op "fsd" (reg_name src) ofs
+
+(* Record live pointers at call points *)
+
+let record_frame_label ?label live dbg =
+ let lbl =
+ match label with
+ | None -> new_label()
+ | Some label -> label
+ in
+ let live_offset = ref [] in
+ Reg.Set.iter
+ (function
+ {typ = Val; loc = Reg r} ->
+ live_offset := (r lsl 1) + 1 :: !live_offset
+ | {typ = Val; loc = Stack s} as reg ->
+ live_offset := slot_offset s (register_class reg) :: !live_offset
+ | {typ = Addr} as r ->
+ Misc.fatal_error ("bad GC root " ^ Reg.name r)
+ | _ -> ()
+ )
+ live;
+ record_frame_descr ~label:lbl ~frame_size:(frame_size())
+ ~live_offset:!live_offset dbg;
+ lbl
+
+let record_frame ?label live dbg =
+ let lbl = record_frame_label ?label live dbg in
+ `{emit_label lbl}:\n`
+
+(* Record calls to the GC -- we've moved them out of the way *)
+
+type gc_call =
+ { gc_lbl: label; (* Entry label *)
+ gc_return_lbl: label; (* Where to branch after GC *)
+ gc_frame_lbl: label } (* Label of frame descriptor *)
+
+let call_gc_sites = ref ([] : gc_call list)
+
+let emit_call_gc gc =
+ `{emit_label gc.gc_lbl}:\n`;
+ ` {emit_call "caml_call_gc"}\n`;
+ `{emit_label gc.gc_frame_lbl}:\n`;
+ ` j {emit_label gc.gc_return_lbl}\n`
+
+(* Record calls to caml_ml_array_bound_error.
+ In debug mode, we maintain one call to caml_ml_array_bound_error
+ per bound check site. Otherwise, we can share a single call. *)
+
+type bound_error_call =
+ { bd_lbl: label; (* Entry label *)
+ bd_frame_lbl: label } (* Label of frame descriptor *)
+
+let bound_error_sites = ref ([] : bound_error_call list)
+
+let bound_error_label ?label dbg =
+ if !Clflags.debug || !bound_error_sites = [] then begin
+ let lbl_bound_error = new_label() in
+ let lbl_frame = record_frame_label ?label Reg.Set.empty (Dbg_other dbg) in
+ bound_error_sites :=
+ { bd_lbl = lbl_bound_error;
+ bd_frame_lbl = lbl_frame } :: !bound_error_sites;
+ lbl_bound_error
+ end else
+ let bd = List.hd !bound_error_sites in
+ bd.bd_lbl
+
+let emit_call_bound_error bd =
+ `{emit_label bd.bd_lbl}:\n`;
+ ` {emit_call "caml_ml_array_bound_error"}\n`;
+ `{emit_label bd.bd_frame_lbl}:\n`
+
+(* Record floating-point literals *)
+
+let float_literals = ref ([] : (int64 * int) list)
+
+(* Names for various instructions *)
+
+let name_for_intop = function
+ | Iadd -> "add"
+ | Isub -> "sub"
+ | Imul -> "mul"
+ | Imulh -> "mulh"
+ | Idiv -> "div"
+ | Iand -> "and"
+ | Ior -> "or"
+ | Ixor -> "xor"
+ | Ilsl -> "sll"
+ | Ilsr -> "srl"
+ | Iasr -> "sra"
+ | Imod -> "rem"
+ | _ -> Misc.fatal_error "Emit.Intop"
+
+let name_for_intop_imm = function
+ | Iadd -> "addi"
+ | Iand -> "andi"
+ | Ior -> "ori"
+ | Ixor -> "xori"
+ | Ilsl -> "slli"
+ | Ilsr -> "srli"
+ | Iasr -> "srai"
+ | _ -> Misc.fatal_error "Emit.Intop_imm"
+
+let name_for_floatop1 = function
+ | Inegf -> "fneg.d"
+ | Iabsf -> "fabs.d"
+ | _ -> Misc.fatal_error "Emit.Iopf1"
+
+let name_for_floatop2 = function
+ | Iaddf -> "fadd.d"
+ | Isubf -> "fsub.d"
+ | Imulf -> "fmul.d"
+ | Idivf -> "fdiv.d"
+ | _ -> Misc.fatal_error "Emit.Iopf2"
+
+let name_for_specific = function
+ | Imultaddf false -> "fmadd.d"
+ | Imultaddf true -> "fnmadd.d"
+ | Imultsubf false -> "fmsub.d"
+ | Imultsubf true -> "fnmsub.d"
+
+(* Name of current function *)
+let function_name = ref ""
+
+(* Entry point for tail recursive calls *)
+let tailrec_entry_point = ref 0
+
+(* Output the assembly code for an instruction *)
+
+let emit_instr i =
+ emit_debug_info i.dbg;
+ match i.desc with
+ Lend -> ()
+ | Lprologue ->
+ assert (!prologue_required);
+ let n = frame_size() in
+ emit_stack_adjustment (-n);
+ if !contains_calls then store_ra n
+ | Lop(Imove | Ispill | Ireload) ->
+ let src = i.arg.(0) and dst = i.res.(0) in
+ if src.loc <> dst.loc then begin
+ match (src, dst) with
+ | {loc = Reg _; typ = (Val | Int | Addr)}, {loc = Reg _} ->
+ ` mv {emit_reg dst}, {emit_reg src}\n`
+ | {loc = Reg _; typ = Float}, {loc = Reg _; typ = Float} ->
+ ` fmv.d {emit_reg dst}, {emit_reg src}\n`
+ | {loc = Reg _; typ = Float}, {loc = Reg _; typ = (Val | Int | Addr)} ->
+ ` fmv.x.d {emit_reg dst}, {emit_reg src}\n`
+ | {loc = Reg _; typ = (Val | Int | Addr)}, {loc = Stack s} ->
+ let ofs = slot_offset s (register_class dst) in
+ emit_store src ofs
+ | {loc = Reg _; typ = Float}, {loc = Stack s} ->
+ let ofs = slot_offset s (register_class dst) in
+ emit_float_store src ofs
+ | {loc = Stack s; typ = (Val | Int | Addr)}, {loc = Reg _} ->
+ let ofs = slot_offset s (register_class src) in
+ emit_load dst ofs
+ | {loc = Stack s; typ = Float}, {loc = Reg _} ->
+ let ofs = slot_offset s (register_class src) in
+ emit_float_load dst ofs
+ | {loc = Stack _}, {loc = Stack _}
+ | {loc = Unknown}, _ | _, {loc = Unknown} ->
+ Misc.fatal_error "Emit: Imove"
+ end
+ | Lop(Iconst_int n) ->
+ ` li {emit_reg i.res.(0)}, {emit_nativeint n}\n`
+ | Lop(Iconst_float f) ->
+ let lbl = new_label() in
+ float_literals := (f, lbl) :: !float_literals;
+ ` fld {emit_reg i.res.(0)}, {emit_label lbl}, {emit_reg reg_tmp}\n`
+ | Lop(Iconst_symbol s) ->
+ ` la {emit_reg i.res.(0)}, {emit_symbol s}\n`
+ | Lop(Icall_ind {label_after = label}) ->
+ ` jalr {emit_reg i.arg.(0)}\n`;
+ record_frame ~label i.live (Dbg_other i.dbg)
+ | Lop(Icall_imm {func; label_after = label}) ->
+ ` {emit_call func}\n`;
+ record_frame ~label i.live (Dbg_other i.dbg)
+ | Lop(Itailcall_ind {label_after = _}) ->
+ let n = frame_size() in
+ if !contains_calls then reload_ra n;
+ emit_stack_adjustment n;
+ ` jr {emit_reg i.arg.(0)}\n`
+ | Lop(Itailcall_imm {func; label_after = _}) ->
+ if func = !function_name then begin
+ ` j {emit_label !tailrec_entry_point}\n`
+ end else begin
+ let n = frame_size() in
+ if !contains_calls then reload_ra n;
+ emit_stack_adjustment n;
+ ` {emit_tail func}\n`
+ end
+ | Lop(Iextcall{func; alloc = true; label_after = label}) ->
+ ` la {emit_reg reg_t2}, {emit_symbol func}\n`;
+ ` {emit_call "caml_c_call"}\n`;
+ record_frame ~label i.live (Dbg_other i.dbg)
+ | Lop(Iextcall{func; alloc = false; label_after = _}) ->
+ ` {emit_call func}\n`
+ | Lop(Istackoffset n) ->
+ assert (n mod 16 = 0);
+ emit_stack_adjustment (-n);
+ stack_offset := !stack_offset + n
+ | Lop(Iload(Single, Iindexed ofs)) ->
+ ` flw {emit_reg i.res.(0)}, {emit_int ofs}({emit_reg i.arg.(0)})\n`;
+ ` fcvt.d.s {emit_reg i.res.(0)}, {emit_reg i.res.(0)}\n`
+ | Lop(Iload(chunk, Iindexed ofs)) ->
+ let instr =
+ match chunk with
+ | Byte_unsigned -> "lbu"
+ | Byte_signed -> "lb"
+ | Sixteen_unsigned -> "lhu"
+ | Sixteen_signed -> "lh"
+ | Thirtytwo_unsigned -> "lwu"
+ | Thirtytwo_signed -> "lw"
+ | Word_int | Word_val -> "ld"
+ | Single -> assert false
+ | Double | Double_u -> "fld"
+ in
+ ` {emit_string instr} {emit_reg i.res.(0)}, {emit_int ofs}({emit_reg i.arg.(0)})\n`
+ | Lop(Istore(Single, Iindexed ofs, _)) ->
+ (* ft0 is marked as destroyed for this operation *)
+ ` fcvt.s.d ft0, {emit_reg i.arg.(0)}\n`;
+ ` fsw ft0, {emit_int ofs}({emit_reg i.arg.(1)})\n`
+ | Lop(Istore(chunk, Iindexed ofs, _)) ->
+ let instr =
+ match chunk with
+ | Byte_unsigned | Byte_signed -> "sb"
+ | Sixteen_unsigned | Sixteen_signed -> "sh"
+ | Thirtytwo_unsigned | Thirtytwo_signed -> "sw"
+ | Word_int | Word_val -> "sd"
+ | Single -> assert false
+ | Double | Double_u -> "fsd"
+ in
+ ` {emit_string instr} {emit_reg i.arg.(0)}, {emit_int ofs}({emit_reg i.arg.(1)})\n`
+ | Lop(Ialloc {bytes; label_after_call_gc = label; dbginfo}) ->
+ let lbl_frame_lbl = record_frame_label ?label i.live (Dbg_alloc dbginfo) in
+ let lbl_after_alloc = new_label () in
+ let lbl_call_gc = new_label () in
+ let n = -bytes in
+ if is_immediate n then
+ ` addi {emit_reg reg_alloc_ptr}, {emit_reg reg_alloc_ptr}, {emit_int n}\n`
+ else begin
+ ` li {emit_reg reg_tmp}, {emit_int n}\n`;
+ ` add {emit_reg reg_alloc_ptr}, {emit_reg reg_alloc_ptr}, {emit_reg reg_tmp}\n`
+ end;
+ ` bltu {emit_reg reg_alloc_ptr}, {emit_reg reg_alloc_lim}, {emit_label lbl_call_gc}\n`;
+ `{emit_label lbl_after_alloc}:\n`;
+ ` addi {emit_reg i.res.(0)}, {emit_reg reg_alloc_ptr}, {emit_int size_addr}\n`;
+ call_gc_sites :=
+ { gc_lbl = lbl_call_gc;
+ gc_return_lbl = lbl_after_alloc;
+ gc_frame_lbl = lbl_frame_lbl } :: !call_gc_sites
+ | Lop(Iintop(Icomp cmp)) ->
+ begin match cmp with
+ | Isigned Clt ->
+ ` slt {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`
+ | Isigned Cge ->
+ ` slt {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`;
+ ` xori {emit_reg i.res.(0)}, {emit_reg i.res.(0)}, 1\n`;
+ | Isigned Cgt ->
+ ` slt {emit_reg i.res.(0)}, {emit_reg i.arg.(1)}, {emit_reg i.arg.(0)}\n`
+ | Isigned Cle ->
+ ` slt {emit_reg i.res.(0)}, {emit_reg i.arg.(1)}, {emit_reg i.arg.(0)}\n`;
+ ` xori {emit_reg i.res.(0)}, {emit_reg i.res.(0)}, 1\n`;
+ | Isigned Ceq | Iunsigned Ceq ->
+ ` sub {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`;
+ ` seqz {emit_reg i.res.(0)}, {emit_reg i.res.(0)}\n`
+ | Isigned Cne | Iunsigned Cne ->
+ ` sub {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`;
+ ` snez {emit_reg i.res.(0)}, {emit_reg i.res.(0)}\n`
+ | Iunsigned Clt ->
+ ` sltu {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`
+ | Iunsigned Cge ->
+ ` sltu {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`;
+ ` xori {emit_reg i.res.(0)}, {emit_reg i.res.(0)}, 1\n`;
+ | Iunsigned Cgt ->
+ ` sltu {emit_reg i.res.(0)}, {emit_reg i.arg.(1)}, {emit_reg i.arg.(0)}\n`
+ | Iunsigned Cle ->
+ ` sltu {emit_reg i.res.(0)}, {emit_reg i.arg.(1)}, {emit_reg i.arg.(0)}\n`;
+ ` xori {emit_reg i.res.(0)}, {emit_reg i.res.(0)}, 1\n`;
+ end
+ | Lop(Iintop (Icheckbound {label_after_error = label; _})) ->
+ let lbl = bound_error_label ?label i.dbg in
+ ` bleu {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}, {emit_label lbl}\n`
+ | Lop(Iintop op) ->
+ let instr = name_for_intop op in
+ ` {emit_string instr} {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`
+ | Lop(Iintop_imm(Isub, n)) ->
+ ` addi {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_int(-n)}\n`
+ | Lop(Iintop_imm(Icomp _, _)) ->
+ Misc.fatal_error "Emit.emit_instr (Iintop_imm (Icomp _, _))"
+ | Lop(Iintop_imm(Icheckbound {label_after_error = label; _}, n)) ->
+ let lbl = bound_error_label ?label i.dbg in
+ ` li {emit_reg reg_tmp}, {emit_int n}\n`;
+ ` bleu {emit_reg i.arg.(0)}, {emit_reg reg_tmp}, {emit_label lbl}\n`
+ | Lop(Iintop_imm(op, n)) ->
+ let instr = name_for_intop_imm op in
+ ` {emit_string instr} {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_int n}\n`
+ | Lop(Inegf | Iabsf as op) ->
+ let instr = name_for_floatop1 op in
+ ` {emit_string instr} {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}\n`
+ | Lop(Iaddf | Isubf | Imulf | Idivf as op) ->
+ let instr = name_for_floatop2 op in
+ ` {emit_string instr} {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`
+ | Lop(Ifloatofint) ->
+ ` fcvt.d.l {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}\n`
+ | Lop(Iintoffloat) ->
+ ` fcvt.l.d {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, rtz\n`
+ | Lop(Ispecific sop) ->
+ let instr = name_for_specific sop in
+ ` {emit_string instr} {emit_reg i.res.(0)}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}, {emit_reg i.arg.(2)}\n`
+ | Lop (Iname_for_debugger _) ->
+ ()
+ | Lreloadretaddr ->
+ let n = frame_size () in
+ reload_ra n
+ | Lreturn ->
+ let n = frame_size() in
+ emit_stack_adjustment n;
+ ` ret\n`
+ | Llabel lbl ->
+ `{emit_label lbl}:\n`
+ | Lbranch lbl ->
+ ` j {emit_label lbl}\n`
+ | Lcondbranch(tst, lbl) ->
+ begin match tst with
+ | Itruetest ->
+ ` bnez {emit_reg i.arg.(0)}, {emit_label lbl}\n`
+ | Ifalsetest ->
+ ` beqz {emit_reg i.arg.(0)}, {emit_label lbl}\n`
+ | Iinttest cmp ->
+ let name = match cmp with
+ | Iunsigned Ceq | Isigned Ceq -> "beq"
+ | Iunsigned Cne | Isigned Cne -> "bne"
+ | Iunsigned Cle -> "bleu" | Isigned Cle -> "ble"
+ | Iunsigned Cge -> "bgeu" | Isigned Cge -> "bge"
+ | Iunsigned Clt -> "bltu" | Isigned Clt -> "blt"
+ | Iunsigned Cgt -> "bgtu" | Isigned Cgt -> "bgt"
+ in
+ ` {emit_string name} {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}, {emit_label lbl}\n`
+ | Iinttest_imm _ ->
+ Misc.fatal_error "Emit.emit_instr (Iinttest_imm _)"
+ | Ifloattest cmp ->
+ let branch =
+ match cmp with
+ | CFneq | CFnlt | CFngt | CFnle | CFnge -> "beqz"
+ | CFeq | CFlt | CFgt | CFle | CFge -> "bnez"
+ in
+ begin match cmp with
+ | CFeq | CFneq -> ` feq.d {emit_reg reg_tmp}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`
+ | CFlt | CFnlt -> ` flt.d {emit_reg reg_tmp}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`
+ | CFgt | CFngt -> ` flt.d {emit_reg reg_tmp}, {emit_reg i.arg.(1)}, {emit_reg i.arg.(0)}\n`
+ | CFle | CFnle -> ` fle.d {emit_reg reg_tmp}, {emit_reg i.arg.(0)}, {emit_reg i.arg.(1)}\n`
+ | CFge | CFnge -> ` fle.d {emit_reg reg_tmp}, {emit_reg i.arg.(1)}, {emit_reg i.arg.(0)}\n`
+ end;
+ ` {emit_string branch} {emit_reg reg_tmp}, {emit_label lbl}\n`
+ | Ioddtest ->
+ ` andi {emit_reg reg_tmp}, {emit_reg i.arg.(0)}, 1\n`;
+ ` bnez {emit_reg reg_tmp}, {emit_label lbl}\n`
+ | Ieventest ->
+ ` andi {emit_reg reg_tmp}, {emit_reg i.arg.(0)}, 1\n`;
+ ` beqz {emit_reg reg_tmp}, {emit_label lbl}\n`
+ end
+ | Lcondbranch3(lbl0, lbl1, lbl2) ->
+ ` addi {emit_reg reg_tmp}, {emit_reg i.arg.(0)}, -1\n`;
+ begin match lbl0 with
+ | None -> ()
+ | Some lbl -> ` bltz {emit_reg reg_tmp}, {emit_label lbl}\n`
+ end;
+ begin match lbl1 with
+ | None -> ()
+ | Some lbl -> ` beqz {emit_reg reg_tmp}, {emit_label lbl}\n`
+ end;
+ begin match lbl2 with
+ | None -> ()
+ | Some lbl -> ` bgtz {emit_reg reg_tmp}, {emit_label lbl}\n`
+ end
+ | Lswitch jumptbl ->
+ (* t0 is marked as destroyed for this operation *)
+ let lbl = new_label() in
+ ` la {emit_reg reg_tmp}, {emit_label lbl}\n`;
+ ` slli t0, {emit_reg i.arg.(0)}, 2\n`;
+ ` add {emit_reg reg_tmp}, {emit_reg reg_tmp}, t0\n`;
+ ` jr {emit_reg reg_tmp}\n`;
+ `{emit_label lbl}:\n`;
+ for i = 0 to Array.length jumptbl - 1 do
+ ` j {emit_label jumptbl.(i)}\n`
+ done
+ | Lentertrap ->
+ ()
+ | Ladjust_trap_depth { delta_traps } ->
+ (* each trap occupes 16 bytes on the stack *)
+ let delta = 16 * delta_traps in
+ stack_offset := !stack_offset + delta
+ | Lpushtrap {lbl_handler} ->
+ ` la {emit_reg reg_tmp}, {emit_label lbl_handler}\n`;
+ ` addi sp, sp, -16\n`;
+ stack_offset := !stack_offset + 16;
+ emit_store reg_tmp size_addr;
+ emit_store reg_trap 0;
+ ` mv {emit_reg reg_trap}, sp\n`
+ | Lpoptrap ->
+ emit_load reg_trap 0;
+ ` addi sp, sp, 16\n`;
+ stack_offset := !stack_offset - 16
+ | Lraise k ->
+ begin match k with
+ | Lambda.Raise_regular ->
+ let offset = Domainstate.(idx_of_field Domain_backtrace_pos) * 8 in
+ ` sd zero, {emit_int offset}({emit_reg reg_domain_state_ptr})\n`;
+ ` {emit_call "caml_raise_exn"}\n`;
+ record_frame Reg.Set.empty (Dbg_raise i.dbg)
+ | Lambda.Raise_reraise ->
+ ` {emit_call "caml_raise_exn"}\n`;
+ record_frame Reg.Set.empty (Dbg_raise i.dbg)
+ | Lambda.Raise_notrace ->
+ ` mv sp, {emit_reg reg_trap}\n`;
+ emit_load reg_tmp size_addr;
+ emit_load reg_trap 0;
+ ` addi sp, sp, 16\n`;
+ ` jr {emit_reg reg_tmp}\n`
+ end
+
+(* Emit a sequence of instructions *)
+
+let rec emit_all = function
+ | {desc = Lend} -> () | i -> emit_instr i; emit_all i.next
+
+(* Emission of a function declaration *)
+
+let fundecl fundecl =
+ function_name := fundecl.fun_name;
+ tailrec_entry_point := fundecl.fun_tailrec_entry_point_label;
+ stack_offset := 0;
+ call_gc_sites := [];
+ bound_error_sites := [];
+ for i = 0 to Proc.num_register_classes - 1 do
+ num_stack_slots.(i) <- fundecl.fun_num_stack_slots.(i);
+ done;
+ prologue_required := fundecl.fun_prologue_required;
+ contains_calls := fundecl.fun_contains_calls;
+ float_literals := [];
+ ` .globl {emit_symbol fundecl.fun_name}\n`;
+ ` .type {emit_symbol fundecl.fun_name}, @function\n`;
+ ` {emit_string code_space}\n`;
+ ` .align 2\n`;
+ `{emit_symbol fundecl.fun_name}:\n`;
+ emit_debug_info fundecl.fun_dbg;
+ emit_all fundecl.fun_body;
+ List.iter emit_call_gc !call_gc_sites;
+ List.iter emit_call_bound_error !bound_error_sites;
+ ` .size {emit_symbol fundecl.fun_name}, .-{emit_symbol fundecl.fun_name}\n`;
+ (* Emit the float literals *)
+ if !float_literals <> [] then begin
+ ` {emit_string rodata_space}\n`;
+ ` .align 3\n`;
+ List.iter
+ (fun (f, lbl) ->
+ `{emit_label lbl}:\n`;
+ emit_float64_directive ".quad" f)
+ !float_literals;
+ end
+
+(* Emission of data *)
+
+let declare_global_data s =
+ ` .globl {emit_symbol s}\n`;
+ ` .type {emit_symbol s}, @object\n`
+
+let emit_item = function
+ | Cglobal_symbol s ->
+ declare_global_data s
+ | Cdefine_symbol s ->
+ `{emit_symbol s}:\n`;
+ | Cint8 n ->
+ ` .byte {emit_int n}\n`
+ | Cint16 n ->
+ ` .short {emit_int n}\n`
+ | Cint32 n ->
+ ` .long {emit_nativeint n}\n`
+ | Cint n ->
+ ` .quad {emit_nativeint n}\n`
+ | Csingle f ->
+ emit_float32_directive ".long" (Int32.bits_of_float f)
+ | Cdouble f ->
+ emit_float64_directive ".quad" (Int64.bits_of_float f)
+ | Csymbol_address s ->
+ ` .quad {emit_symbol s}\n`
+ | Cstring s ->
+ emit_bytes_directive " .byte " s
+ | Cskip n ->
+ if n > 0 then ` .space {emit_int n}\n`
+ | Calign n ->
+ ` .align {emit_int (Misc.log2 n)}\n`
+
+let data l =
+ ` {emit_string data_space}\n`;
+ List.iter emit_item l
+
+(* Beginning / end of an assembly file *)
+
+let begin_assembly() =
+ if !Clflags.dlcode || !Clflags.pic_code then ` .option pic\n`;
+ ` .file \"\"\n`; (* PR#7073 *)
+ reset_debug_info ();
+ (* Emit the beginning of the segments *)
+ let lbl_begin = Compilenv.make_symbol (Some "data_begin") in
+ ` {emit_string data_space}\n`;
+ declare_global_data lbl_begin;
+ `{emit_symbol lbl_begin}:\n`;
+ let lbl_begin = Compilenv.make_symbol (Some "code_begin") in
+ ` {emit_string code_space}\n`;
+ declare_global_data lbl_begin;
+ `{emit_symbol lbl_begin}:\n`
+
+let end_assembly() =
+ ` {emit_string code_space}\n`;
+ let lbl_end = Compilenv.make_symbol (Some "code_end") in
+ declare_global_data lbl_end;
+ `{emit_symbol lbl_end}:\n`;
+ ` .long 0\n`;
+ ` {emit_string data_space}\n`;
+ let lbl_end = Compilenv.make_symbol (Some "data_end") in
+ declare_global_data lbl_end;
+ ` .quad 0\n`; (* PR#6329 *)
+ `{emit_symbol lbl_end}:\n`;
+ ` .quad 0\n`;
+ (* Emit the frame descriptors *)
+ ` {emit_string rodata_space}\n`;
+ let lbl = Compilenv.make_symbol (Some "frametable") in
+ declare_global_data lbl;
+ `{emit_symbol lbl}:\n`;
+ emit_frames
+ { efa_code_label = (fun l -> ` .quad {emit_label l}\n`);
+ efa_data_label = (fun l -> ` .quad {emit_label l}\n`);
+ efa_8 = (fun n -> ` .byte {emit_int n}\n`);
+ efa_16 = (fun n -> ` .short {emit_int n}\n`);
+ efa_32 = (fun n -> ` .long {emit_int32 n}\n`);
+ efa_word = (fun n -> ` .quad {emit_int n}\n`);
+ efa_align = (fun n -> ` .align {emit_int (Misc.log2 n)}\n`);
+ efa_label_rel = (fun lbl ofs ->
+ ` .long ({emit_label lbl} - .) + {emit_int32 ofs}\n`);
+ efa_def_label = (fun l -> `{emit_label l}:\n`);
+ efa_string = (fun s -> emit_bytes_directive " .byte " (s ^ "\000"))
+ }
--- /dev/null
+(**************************************************************************)
+(* *)
+(* OCaml *)
+(* *)
+(* Nicolas Ojeda Bar <n.oje.bar@gmail.com> *)
+(* *)
+(* Copyright 2016 Institut National de Recherche en Informatique et *)
+(* en Automatique. *)
+(* *)
+(* All rights reserved. This file is distributed under the terms of *)
+(* the GNU Lesser General Public License version 2.1, with the *)
+(* special exception on linking described in the file LICENSE. *)
+(* *)
+(**************************************************************************)
+
+(* Description of the RISC-V *)
+
+open Misc
+open Cmm
+open Reg
+open Arch
+open Mach
+
+(* Instruction selection *)
+
+let word_addressed = false
+
+(* Registers available for register allocation *)
+
+(* Integer register map
+ --------------------
+
+ zero always zero
+ ra return address
+ sp, gp, tp stack pointer, global pointer, thread pointer
+ a0-a7 0-7 arguments/results
+ s2-s9 8-15 arguments/results (preserved by C)
+ t2-t6 16-20 temporary
+ t0-t1 21-22 temporary (used by code generator)
+ s0 23 domain pointer (preserved by C)
+ s1 24 trap pointer (preserved by C)
+ s10 25 allocation pointer (preserved by C)
+ s11 26 allocation limit (preserved by C)
+
+ Floating-point register map
+ ---------------------------
+
+ ft0-ft7 100-107 temporary
+ fs0-fs1 108-109 general purpose (preserved by C)
+ fa0-fa7 110-117 arguments/results
+ fs2-fs9 118-125 arguments/results (preserved by C)
+ fs10-fs11 126-127 general purpose (preserved by C)
+ ft8-ft11 128-131 temporary
+
+ Additional notes
+ ----------------
+
+ - t0-t1 are used by the assembler and code generator, so
+ not available for register allocation.
+
+ - t0-t6 may be used by PLT stubs, so should not be used to pass
+ arguments and may be clobbered by [Ialloc] in the presence of dynamic
+ linking.
+*)
+
+let int_reg_name =
+ [| "a0"; "a1"; "a2"; "a3"; "a4"; "a5"; "a6"; "a7";
+ "s2"; "s3"; "s4"; "s5"; "s6"; "s7"; "s8"; "s9";
+ "t2"; "t3"; "t4"; "t5"; "t6";
+ "t0"; "t1";
+ "s0"; "s1"; "s10"; "s11" |]
+
+let float_reg_name =
+ [| "ft0"; "ft1"; "ft2"; "ft3"; "ft4"; "ft5"; "ft6"; "ft7";
+ "fs0"; "fs1";
+ "fa0"; "fa1"; "fa2"; "fa3"; "fa4"; "fa5"; "fa6"; "fa7";
+ "fs2"; "fs3"; "fs4"; "fs5"; "fs6"; "fs7"; "fs8"; "fs9"; "fs10"; "fs11";
+ "ft8"; "ft9"; "ft10"; "ft11" |]
+
+let num_register_classes = 2
+
+let register_class r =
+ match r.typ with
+ | Val | Int | Addr -> 0
+ | Float -> 1
+
+let num_available_registers = [| 22; 32 |]
+
+let first_available_register = [| 0; 100 |]
+
+let register_name r =
+ if r < 100 then int_reg_name.(r) else float_reg_name.(r - 100)
+
+let rotate_registers = true
+
+(* Representation of hard registers by pseudo-registers *)
+
+let hard_int_reg =
+ let v = Array.make 27 Reg.dummy in
+ for i = 0 to 26 do
+ v.(i) <- Reg.at_location Int (Reg i)
+ done;
+ v
+
+let hard_float_reg =
+ let v = Array.make 32 Reg.dummy in
+ for i = 0 to 31 do
+ v.(i) <- Reg.at_location Float (Reg(100 + i))
+ done;
+ v
+
+let all_phys_regs =
+ Array.append hard_int_reg hard_float_reg
+
+let phys_reg n =
+ if n < 100 then hard_int_reg.(n) else hard_float_reg.(n - 100)
+
+let stack_slot slot ty =
+ Reg.at_location ty (Stack slot)
+
+(* Calling conventions *)
+
+let calling_conventions
+ first_int last_int first_float last_float make_stack arg =
+ let loc = Array.make (Array.length arg) Reg.dummy in
+ let int = ref first_int in
+ let float = ref first_float in
+ let ofs = ref 0 in
+ for i = 0 to Array.length arg - 1 do
+ match arg.(i).typ with
+ | Val | Int | Addr as ty ->
+ if !int <= last_int then begin
+ loc.(i) <- phys_reg !int;
+ incr int
+ end else begin
+ loc.(i) <- stack_slot (make_stack !ofs) ty;
+ ofs := !ofs + size_int
+ end
+ | Float ->
+ if !float <= last_float then begin
+ loc.(i) <- phys_reg !float;
+ incr float
+ end else begin
+ loc.(i) <- stack_slot (make_stack !ofs) Float;
+ ofs := !ofs + size_float
+ end
+ done;
+ (loc, Misc.align !ofs 16) (* Keep stack 16-aligned. *)
+
+let incoming ofs = Incoming ofs
+let outgoing ofs = Outgoing ofs
+let not_supported _ = fatal_error "Proc.loc_results: cannot call"
+
+let max_arguments_for_tailcalls = 16
+
+let loc_spacetime_node_hole = Reg.dummy (* Spacetime unsupported *)
+
+(* OCaml calling convention:
+ first integer args in a0 .. a7, s2 .. s9
+ first float args in fa0 .. fa7, fs2 .. fs9
+ remaining args on stack.
+ Return values in a0 .. a7, s2 .. s9 or fa0 .. fa7, fs2 .. fs9. *)
+
+let single_regs arg = Array.map (fun arg -> [| arg |]) arg
+let ensure_single_regs res =
+ Array.map (function
+ | [| res |] -> res
+ | _ -> failwith "proc.ensure_single_regs"
+ ) res
+
+let loc_arguments arg =
+ calling_conventions 0 15 110 125 outgoing arg
+
+let loc_parameters arg =
+ let (loc, _ofs) =
+ calling_conventions 0 15 110 125 incoming arg
+ in
+ loc
+
+let loc_results res =
+ let (loc, _ofs) =
+ calling_conventions 0 15 110 125 not_supported res
+ in
+ loc
+
+(* C calling convention:
+ first integer args in a0 .. a7
+ first float args in fa0 .. fa7
+ remaining args on stack.
+ A FP argument can be passed in an integer register if all FP registers
+ are exhausted but integer registers remain.
+ Return values in a0 .. a1 or fa0 .. fa1. *)
+
+let external_calling_conventions
+ first_int last_int first_float last_float make_stack arg =
+ let loc = Array.make (Array.length arg) [| Reg.dummy |] in
+ let int = ref first_int in
+ let float = ref first_float in
+ let ofs = ref 0 in
+ for i = 0 to Array.length arg - 1 do
+ match arg.(i) with
+ | [| arg |] ->
+ begin match arg.typ with
+ | Val | Int | Addr as ty ->
+ if !int <= last_int then begin
+ loc.(i) <- [| phys_reg !int |];
+ incr int
+ end else begin
+ loc.(i) <- [| stack_slot (make_stack !ofs) ty |];
+ ofs := !ofs + size_int
+ end
+ | Float ->
+ if !float <= last_float then begin
+ loc.(i) <- [| phys_reg !float |];
+ incr float
+ end else if !int <= last_int then begin
+ loc.(i) <- [| phys_reg !int |];
+ incr int
+ end else begin
+ loc.(i) <- [| stack_slot (make_stack !ofs) Float |];
+ ofs := !ofs + size_float
+ end
+ end
+ | _ ->
+ fatal_error "Proc.calling_conventions: bad number of register for \
+ multi-register argument"
+ done;
+ (loc, Misc.align !ofs 16) (* Keep stack 16-aligned. *)
+
+let loc_external_arguments arg =
+ external_calling_conventions 0 7 110 117 outgoing arg
+
+let loc_external_results res =
+ let (loc, _ofs) =
+ external_calling_conventions 0 1 110 111 not_supported (single_regs res)
+ in
+ ensure_single_regs loc
+
+(* Exceptions are in a0 *)
+
+let loc_exn_bucket = phys_reg 0
+
+(* Volatile registers: none *)
+
+let regs_are_volatile _ = false
+
+(* Registers destroyed by operations *)
+
+let destroyed_at_c_call =
+ (* s0-s11 and fs0-fs11 are callee-save *)
+ Array.of_list(List.map phys_reg
+ [0; 1; 2; 3; 4; 5; 6; 7; 16; 17; 18; 19; 20; 21;
+ 100; 101; 102; 103; 104; 105; 106; 107; 110; 111; 112; 113; 114; 115; 116;
+ 117; 128; 129; 130; 131])
+
+let destroyed_at_alloc =
+ (* t0-t3 are used for PLT stubs *)
+ if !Clflags.dlcode then Array.map phys_reg [|16; 17; 18; 19; 20; 21|]
+ else [| |]
+
+let destroyed_at_oper = function
+ | Iop(Icall_ind _ | Icall_imm _ | Iextcall{alloc = true; _}) -> all_phys_regs
+ | Iop(Iextcall{alloc = false; _}) -> destroyed_at_c_call
+ | Iop(Ialloc _) -> destroyed_at_alloc
+ | Iop(Istore(Single, _, _)) -> [| phys_reg 100 |]
+ | Iswitch _ -> [| phys_reg 21 |]
+ | _ -> [||]
+
+let destroyed_at_raise = all_phys_regs
+
+let destroyed_at_reloadretaddr = [| |]
+
+(* Maximal register pressure *)
+
+let safe_register_pressure = function
+ | Iextcall _ -> 15
+ | _ -> 22
+
+let max_register_pressure = function
+ | Iextcall _ -> [| 15; 18 |]
+ | _ -> [| 22; 30 |]
+
+(* Pure operations (without any side effect besides updating their result
+ registers). *)
+
+let op_is_pure = function
+ | Icall_ind _ | Icall_imm _ | Itailcall_ind _ | Itailcall_imm _
+ | Iextcall _ | Istackoffset _ | Istore _ | Ialloc _
+ | Iintop(Icheckbound _) | Iintop_imm(Icheckbound _, _) -> false
+ | Ispecific(Imultaddf _ | Imultsubf _) -> true
+ | _ -> true
+
+(* Layout of the stack *)
+
+let frame_required fd =
+ fd.fun_contains_calls
+ || fd.fun_num_stack_slots.(0) > 0
+ || fd.fun_num_stack_slots.(1) > 0
+
+let prologue_required fd =
+ frame_required fd
+
+(* See
+ https://github.com/riscv/riscv-elf-psabi-doc/blob/master/riscv-elf.md *)
+
+let int_dwarf_reg_numbers =
+ [| 10; 11; 12; 13; 14; 15; 16; 17;
+ 18; 19; 20; 21; 22; 23; 24; 25;
+ 7; 28; 29; 30; 31;
+ 5; 6;
+ 8; 9; 26; 27;
+ |]
+
+let float_dwarf_reg_numbers =
+ [| 32; 33; 34; 35; 36; 37; 38; 39;
+ 40; 41;
+ 42; 43; 44; 45; 46; 47; 48; 49;
+ 50; 51; 52; 53; 54; 55; 56; 57;
+ 58; 59;
+ 60; 61; 62; 63;
+ |]
+
+let dwarf_register_numbers ~reg_class =
+ match reg_class with
+ | 0 -> int_dwarf_reg_numbers
+ | 1 -> float_dwarf_reg_numbers
+ | _ -> Misc.fatal_errorf "Bad register class %d" reg_class
+
+let stack_ptr_dwarf_register_number = 2
+
+(* Calling the assembler *)
+
+let assemble_file infile outfile =
+ Ccomp.command
+ (Config.asm ^ " -o " ^ Filename.quote outfile ^ " " ^ Filename.quote infile)
+
+let init () = ()
--- /dev/null
+(**************************************************************************)
+(* *)
+(* OCaml *)
+(* *)
+(* Nicolas Ojeda Bar <n.oje.bar@gmail.com> *)
+(* *)
+(* Copyright 2016 Institut National de Recherche en Informatique et *)
+(* en Automatique. *)
+(* *)
+(* All rights reserved. This file is distributed under the terms of *)
+(* the GNU Lesser General Public License version 2.1, with the *)
+(* special exception on linking described in the file LICENSE. *)
+(* *)
+(**************************************************************************)
+
+(* Reloading for the RISC-V *)
+
+let fundecl f =
+ (new Reloadgen.reload_generic)#fundecl f
--- /dev/null
+(**************************************************************************)
+(* *)
+(* OCaml *)
+(* *)
+(* Nicolas Ojeda Bar <n.oje.bar@gmail.com> *)
+(* *)
+(* Copyright 2016 Institut National de Recherche en Informatique et *)
+(* en Automatique. *)
+(* *)
+(* All rights reserved. This file is distributed under the terms of *)
+(* the GNU Lesser General Public License version 2.1, with the *)
+(* special exception on linking described in the file LICENSE. *)
+(* *)
+(**************************************************************************)
+
+(* Instruction scheduling for the RISC-V *)
+
+open! Schedgen (* to create a dependency *)
+
+(* Scheduling is turned off. *)
+
+let fundecl f = f
--- /dev/null
+(**************************************************************************)
+(* *)
+(* OCaml *)
+(* *)
+(* Nicolas Ojeda Bar <n.oje.bar@gmail.com> *)
+(* *)
+(* Copyright 2016 Institut National de Recherche en Informatique et *)
+(* en Automatique. *)
+(* *)
+(* All rights reserved. This file is distributed under the terms of *)
+(* the GNU Lesser General Public License version 2.1, with the *)
+(* special exception on linking described in the file LICENSE. *)
+(* *)
+(**************************************************************************)
+
+(* Instruction selection for the RISC-V processor *)
+
+open Cmm
+open Arch
+open Mach
+
+(* Instruction selection *)
+
+class selector = object (self)
+
+inherit Selectgen.selector_generic as super
+
+method is_immediate n = is_immediate n
+
+method select_addressing _ = function
+ | Cop(Cadda, [arg; Cconst_int (n, _)], _) when self#is_immediate n ->
+ (Iindexed n, arg)
+ | Cop(Cadda, [arg1; Cop(Caddi, [arg2; Cconst_int (n, _)], _)], dbg)
+ when self#is_immediate n ->
+ (Iindexed n, Cop(Caddi, [arg1; arg2], dbg))
+ | arg ->
+ (Iindexed 0, arg)
+
+method! select_operation op args dbg =
+ match (op, args) with
+ (* Recognize (neg-)mult-add and (neg-)mult-sub instructions *)
+ | (Caddf, [Cop(Cmulf, [arg1; arg2], _); arg3])
+ | (Caddf, [arg3; Cop(Cmulf, [arg1; arg2], _)]) ->
+ (Ispecific (Imultaddf false), [arg1; arg2; arg3])
+ | (Csubf, [Cop(Cmulf, [arg1; arg2], _); arg3]) ->
+ (Ispecific (Imultsubf false), [arg1; arg2; arg3])
+ | (Cnegf, [Cop(Csubf, [Cop(Cmulf, [arg1; arg2], _); arg3], _)]) ->
+ (Ispecific (Imultsubf true), [arg1; arg2; arg3])
+ | (Cnegf, [Cop(Caddf, [Cop(Cmulf, [arg1; arg2], _); arg3], _)]) ->
+ (Ispecific (Imultaddf true), [arg1; arg2; arg3])
+ (* RISC-V does not support immediate operands for comparison operators *)
+ | (Ccmpi comp, args) -> (Iintop(Icomp (Isigned comp)), args)
+ | (Ccmpa comp, args) -> (Iintop(Icomp (Iunsigned comp)), args)
+ (* RISC-V does not support immediate operands for multiply/multiply high *)
+ | (Cmuli, _) -> (Iintop Imul, args)
+ | (Cmulhi, _) -> (Iintop Imulh, args)
+ | _ ->
+ super#select_operation op args dbg
+
+(* Instruction selection for conditionals *)
+
+method! select_condition = function
+ Cop(Ccmpi cmp, args, _) ->
+ (Iinttest(Isigned cmp), Ctuple args)
+ | Cop(Ccmpa cmp, args, _) ->
+ (Iinttest(Iunsigned cmp), Ctuple args)
+ | Cop(Ccmpf cmp, args, _) ->
+ (Ifloattest cmp, Ctuple args)
+ | Cop(Cand, [arg; Cconst_int (1, _)], _) ->
+ (Ioddtest, arg)
+ | arg ->
+ (Itruetest, arg)
+end
+
+let fundecl f = (new selector)#emit_fundecl f
(* Record live pointers at call points *)
-let record_frame_label ?label live raise_ dbg =
+let record_frame_label ?label live dbg =
let lbl =
match label with
| None -> new_label()
| _ -> ())
live;
record_frame_descr ~label:lbl ~frame_size:(frame_size())
- ~live_offset:!live_offset ~raise_frame:raise_ dbg;
+ ~live_offset:!live_offset dbg;
lbl
-let record_frame ?label live raise_ dbg =
- let lbl = record_frame_label ?label live raise_ dbg in
+let record_frame ?label live dbg =
+ let lbl = record_frame_label ?label live dbg in
`{emit_label lbl}:`
(* Record calls to caml_call_gc, emitted out of line. *)
let bound_error_label ?label dbg =
if !Clflags.debug then begin
let lbl_bound_error = new_label() in
- let lbl_frame = record_frame_label ?label Reg.Set.empty false dbg in
+ let lbl_frame = record_frame_label ?label Reg.Set.empty (Dbg_other dbg) in
bound_error_sites :=
{ bd_lbl = lbl_bound_error; bd_frame = lbl_frame } :: !bound_error_sites;
lbl_bound_error
emit_load_symbol_addr i.res.(0) s
| Lop(Icall_ind { label_after; }) ->
` basr %r14, {emit_reg i.arg.(0)}\n`;
- `{record_frame i.live false i.dbg ~label:label_after}\n`
+ `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n`
| Lop(Icall_imm { func; label_after; }) ->
emit_call func;
- `{record_frame i.live false i.dbg ~label:label_after}\n`
+ `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n`
| Lop(Itailcall_ind { label_after = _; }) ->
let n = frame_size() in
if !contains_calls then
else begin
emit_load_symbol_addr reg_r7 func;
emit_call "caml_c_call";
- `{record_frame i.live false i.dbg ~label:label_after}\n`
+ `{record_frame i.live (Dbg_other i.dbg) ~label:label_after}\n`
end
| Lop(Istackoffset n) ->
| Double | Double_u -> "stdy" in
emit_load_store storeinstr addr i.arg 1 i.arg.(0)
- | Lop(Ialloc { bytes = n; label_after_call_gc; }) ->
- let lbl_redo = new_label() in
+ | Lop(Ialloc { bytes = n; label_after_call_gc; dbginfo }) ->
+ let lbl_after_alloc = new_label() in
let lbl_call_gc = new_label() in
let lbl_frame =
- record_frame_label i.live false i.dbg ?label:label_after_call_gc
+ record_frame_label i.live (Dbg_alloc dbginfo) ?label:label_after_call_gc
in
call_gc_sites :=
{ gc_lbl = lbl_call_gc;
- gc_return_lbl = lbl_redo;
+ gc_return_lbl = lbl_after_alloc;
gc_frame_lbl = lbl_frame } :: !call_gc_sites;
- `{emit_label lbl_redo}:`;
- ` lay {emit_reg i.res.(0)}, {emit_int(-n+8)}(%r11)\n`;
+ ` lay %r11, {emit_int(-n)}(%r11)\n`;
let offset = Domainstate.(idx_of_field Domain_young_limit) * 8 in
- ` clg {emit_reg i.res.(0)}, {emit_int offset}(%r10)\n`;
- ` brcl 12, {emit_label lbl_call_gc}\n`;
- (* less than or equal *)
- ` lay %r11, -8({emit_reg i.res.(0)})\n`
+ ` clg %r11, {emit_int offset}(%r10)\n`;
+ ` brcl 4, {emit_label lbl_call_gc}\n`; (* less than *)
+ `{emit_label lbl_after_alloc}:`;
+ ` la {emit_reg i.res.(0)}, 8(%r11)\n`
| Lop(Iintop Imulh) ->
(* Hacker's Delight section 8.3:
` lghi %r1, 0\n`;
` stg %r1, {emit_int offset}(%r10)\n`;
emit_call "caml_raise_exn";
- `{record_frame Reg.Set.empty true i.dbg}\n`
+ `{record_frame Reg.Set.empty (Dbg_raise i.dbg)}\n`
| Lambda.Raise_reraise ->
emit_call "caml_raise_exn";
- `{record_frame Reg.Set.empty true i.dbg}\n`
+ `{record_frame Reg.Set.empty (Dbg_raise i.dbg)}\n`
| Lambda.Raise_notrace ->
` lg %r1, 0(%r13)\n`;
` lgr %r15, %r13\n`;
emit_frames
{ efa_code_label = (fun l -> ` .quad {emit_label l}\n`);
efa_data_label = (fun l -> ` .quad {emit_label l}\n`);
+ efa_8 = (fun n -> ` .byte {emit_int n}\n`);
efa_16 = (fun n -> ` .short {emit_int n}\n`);
efa_32 = (fun n -> ` .long {emit_int32 n}\n`);
efa_word = (fun n -> ` .quad {emit_int n}\n`);
module VP = Backend_var.With_provenance
type environment =
- { vars : (Reg.t array * Backend_var.Provenance.t option) V.Map.t;
+ { vars : (Reg.t array
+ * Backend_var.Provenance.t option
+ * Asttypes.mutable_flag) V.Map.t;
static_exceptions : Reg.t array list Int.Map.t;
(** Which registers must be populated when jumping to the given
handler. *)
}
-let env_add var regs env =
+let env_add ?(mut=Asttypes.Immutable) var regs env =
let provenance = VP.provenance var in
let var = VP.var var in
- { env with vars = V.Map.add var (regs, provenance) env.vars }
+ { env with vars = V.Map.add var (regs, provenance, mut) env.vars }
let env_add_static_exception id v env =
{ env with static_exceptions = Int.Map.add id v env.static_exceptions }
let env_find id env =
- let regs, _provenance = V.Map.find id env.vars in
+ let regs, _provenance, _mut = V.Map.find id env.vars in
+ regs
+
+let env_find_mut id env =
+ let regs, _provenance, mut = V.Map.find id env.vars in
+ begin match mut with
+ | Asttypes.Mutable -> ()
+ | Asttypes.Immutable ->
+ Misc.fatal_error "Selectgen.env_find_mut: not mutable"
+ end;
regs
let env_find_static_exception id env =
| Cblockheader _ -> true
| Cvar _ -> true
| Ctuple el -> List.for_all self#is_simple_expr el
- | Clet(_id, arg, body) -> self#is_simple_expr arg && self#is_simple_expr body
+ | Clet(_id, arg, body) | Clet_mut(_id, _, arg, body) ->
+ self#is_simple_expr arg && self#is_simple_expr body
| Cphantom_let(_var, _defining_expr, body) -> self#is_simple_expr body
| Csequence(e1, e2) -> self#is_simple_expr e1 && self#is_simple_expr e2
| Cop(op, args, _) ->
| Cconst_pointer _ | Cconst_natpointer _ | Cblockheader _
| Cvar _ -> EC.none
| Ctuple el -> EC.join_list_map el self#effects_of
- | Clet (_id, arg, body) ->
+ | Clet (_id, arg, body) | Clet_mut (_id, _, arg, body) ->
EC.join (self#effects_of arg) (self#effects_of body)
| Cphantom_let (_var, _defining_expr, body) -> self#effects_of body
| Csequence (e1, e2) ->
(* Default instruction selection for operators *)
method select_allocation bytes =
- Ialloc { bytes; spacetime_index = 0; label_after_call_gc = None; }
+ Ialloc { bytes; label_after_call_gc = None;
+ dbginfo = []; spacetime_index = 0; }
method select_allocation_args _env = [| |]
method select_checkbound () =
self#insert_move env src.(i) dst.(i)
done
-(* Adjust the types of destination pseudoregs for a [Cassign] assignment.
- The type inferred at [let] binding might be [Int] while we assign
- something of type [Val] (PR#6501). *)
-
-method adjust_type src dst =
- let ts = src.typ and td = dst.typ in
- if ts <> td then
- match ts, td with
- | Val, Int -> dst.typ <- Val
- | Int, Val -> ()
- | _, _ -> Misc.fatal_error("Selection.adjust_type: bad assignment to "
- ^ Reg.name dst)
-
-method adjust_types src dst =
- for i = 0 to min (Array.length src) (Array.length dst) - 1 do
- self#adjust_type src.(i) dst.(i)
- done
-
(* Insert moves and stack offsets for function arguments and results *)
method insert_move_args env arg loc stacksize =
let r = self#regs_for typ_float in
Some(self#insert_op env (Iconst_float (Int64.bits_of_float n)) [||] r)
| Cconst_symbol (n, _dbg) ->
- let r = self#regs_for typ_val in
+ (* Cconst_symbol _ evaluates to a statically-allocated address, so its
+ value fits in a typ_int register and is never changed by the GC.
+
+ Some Cconst_symbols point to statically-allocated blocks, some of
+ which may point to heap values. However, any such blocks will be
+ registered in the compilation unit's global roots structure, so
+ adding this register to the frame table would be redundant *)
+ let r = self#regs_for typ_int in
Some(self#insert_op env (Iconst_symbol n) [||] r)
| Cconst_pointer (n, _dbg) ->
- let r = self#regs_for typ_val in (* integer as Caml value *)
+ let r = self#regs_for typ_int in
Some(self#insert_op env (Iconst_int(Nativeint.of_int n)) [||] r)
| Cconst_natpointer (n, _dbg) ->
- let r = self#regs_for typ_val in (* integer as Caml value *)
+ let r = self#regs_for typ_int in
Some(self#insert_op env (Iconst_int n) [||] r)
| Cblockheader(n, dbg) ->
self#emit_blockheader env n dbg
None -> None
| Some r1 -> self#emit_expr (self#bind_let env v r1) e2
end
+ | Clet_mut(v, k, e1, e2) ->
+ begin match self#emit_expr env e1 with
+ None -> None
+ | Some r1 -> self#emit_expr (self#bind_let_mut env v k r1) e2
+ end
| Cphantom_let (_var, _defining_expr, body) ->
self#emit_expr env body
| Cassign(v, e1) ->
let rv =
try
- env_find v env
+ env_find_mut v env
with Not_found ->
Misc.fatal_error ("Selection.emit_expr: unbound var " ^ V.name v) in
begin match self#emit_expr env e1 with
None -> None
| Some r1 ->
- self#adjust_types r1 rv; self#insert_moves env r1 rv; Some [||]
+ self#insert_moves env r1 rv; Some [||]
end
| Ctuple [] ->
Some [||]
| Ialloc { bytes = _; spacetime_index; label_after_call_gc; } ->
let rd = self#regs_for typ_val in
let bytes = size_expr env (Ctuple new_args) in
+ assert (bytes mod Arch.size_addr = 0);
+ let alloc_words = bytes / Arch.size_addr in
let op =
- Ialloc { bytes; spacetime_index; label_after_call_gc; }
+ Ialloc { bytes; spacetime_index; label_after_call_gc;
+ dbginfo = [{alloc_words; alloc_dbg = dbg}] }
in
let args = self#select_allocation_args env in
self#insert_debug env (Iop op) dbg args rd;
env_add v rv env
end
+method private bind_let_mut (env:environment) v k r1 =
+ let rv = self#regs_for k in
+ name_regs v rv;
+ self#insert_moves env r1 rv;
+ env_add ~mut:Mutable v rv env
+
(* The following two functions, [emit_parts] and [emit_parts_list], force
right-to-left evaluation order as required by the Flambda [Un_anf] pass
(and to be consistent with the bytecode compiler). *)
None -> ()
| Some r1 -> self#emit_tail (self#bind_let env v r1) e2
end
+ | Clet_mut (v, k, e1, e2) ->
+ begin match self#emit_expr env e1 with
+ None -> ()
+ | Some r1 -> self#emit_tail (self#bind_let_mut env v k r1) e2
+ end
| Cphantom_let (_var, _defining_expr, body) ->
self#emit_tail env body
| Cop((Capply ty) as op, args, dbg) ->
self#insert_moves env r1 loc;
self#insert env Ireturn loc [||]
end
- | _ ->
- self#emit_return env exp
+ | Cop _
+ | Cconst_int _ | Cconst_natint _ | Cconst_float _ | Cconst_symbol _
+ | Cconst_pointer _ | Cconst_natpointer _ | Cblockheader _
+ | Cvar _
+ | Cassign _
+ | Ctuple _
+ | Cexit _ ->
+ self#emit_return env exp
method private emit_tail_sequence env exp =
let s = {< instr_seq = dummy_instr >} in
type environment
val env_add
- : Backend_var.With_provenance.t
+ : ?mut:Asttypes.mutable_flag
+ -> Backend_var.With_provenance.t
-> Reg.t array
-> environment
-> environment
method insert_move_results :
environment -> Reg.t array -> Reg.t array -> int -> unit
method insert_moves : environment -> Reg.t array -> Reg.t array -> unit
- method adjust_type : Reg.t -> Reg.t -> unit
- method adjust_types : Reg.t array -> Reg.t array -> unit
method emit_expr :
environment -> Cmm.expression -> Reg.t array option
method emit_tail : environment -> Cmm.expression -> unit
in
Mach.Ialloc {
bytes;
+ dbginfo = [];
label_after_call_gc = Some label;
spacetime_index = index;
}
module type I = sig
val string_block_length : Cmm.expression -> Cmm.expression
val transl_switch :
- Location.t -> Cmm.expression -> int -> int ->
+ Debuginfo.t -> Cmm.expression -> int -> int ->
(int * Cmm.expression) list -> Cmm.expression ->
Cmm.expression
end
(len,act))
(by_size cases) in
let id = gen_size_id () in
- let loc = Debuginfo.to_location dbg in
- let switch = I.transl_switch loc (Cvar id) 1 max_int size_cases default in
+ let switch = I.transl_switch dbg (Cvar id) 1 max_int size_cases default in
mk_let_size (VP.create id) str switch
(*
module type I = sig
val string_block_length : Cmm.expression -> Cmm.expression
val transl_switch :
- Location.t -> Cmm.expression -> int -> int ->
+ Debuginfo.t -> Cmm.expression -> int -> int ->
(int * Cmm.expression) list -> Cmm.expression ->
Cmm.expression
end
+++ /dev/null
-#!/bin/sh -e
-#**************************************************************************
-#* *
-#* OCaml *
-#* *
-#* David Allsopp, MetaStack Solutions Ltd. *
-#* *
-#* Copyright 2019 MetaStack Solutions Ltd. *
-#* *
-#* All rights reserved. This file is distributed under the terms of *
-#* the GNU Lesser General Public License version 2.1, with the *
-#* special exception on linking described in the file LICENSE. *
-#* *
-#**************************************************************************
-
-# Remove the autom4te.cache directory to make sure we start in a clean state
-rm -rf autom4te.cache
-
-autoconf --force --warnings=all,error
-
-# Allow pre-processing of configure arguments for Git check-outs
-# The sed call removes dra27's copyright on the whole configure script...
-sed -e '/^#[^!]/d' tools/git-dev-options.sh > configure.tmp
-
-# Some distros have the 2013 --runstatedir patch to autoconf (see
-# http://git.savannah.gnu.org/cgit/autoconf.git/commit/?id=a197431414088a417b407b9b20583b2e8f7363bd
-# in the GNU autoconf repo), and some don't, so ensure its effects are
-# removed for CI consistency...
-# POSIX Notes
-# - sed -i without a backup file is not portable, hence configure.tmp
-# - GNU sed's /../,+8d becomes /../{N;..;d;} (and the last ; is important)
-sed -e '/^runstatedir/d' \
- -e '/-runstatedir /{N;N;N;N;N;N;N;N;d;}' \
- -e '/--runstatedir=DIR/d' \
- -e 's/ runstatedir//' \
- -e '1d' \
- configure >> configure.tmp
-
-mv -f configure.tmp configure
-chmod +x configure
end
end
module StaticVersion = struct
-let require_20181113 = ()
+let require_20190924 = ()
end
and type nonterminal = int
end
module StaticVersion : sig
-val require_20181113 : unit
+val require_20190924 : unit
end
(* This generated code requires the following version of MenhirLib: *)
let () =
- MenhirLib.StaticVersion.require_20181113
+ MenhirLib.StaticVersion.require_20190924
module MenhirBasics = struct
| VAL
| UNDERSCORE
| UIDENT of (
-# 688 "parsing/parser.mly"
+# 697 "parsing/parser.mly"
(string)
# 22 "parsing/parser.ml"
)
| THEN
| STRUCT
| STRING of (
-# 680 "parsing/parser.mly"
- (string * string option)
+# 685 "parsing/parser.mly"
+ (string * Location.t * string option)
# 34 "parsing/parser.ml"
)
| STAR
| REC
| RBRACKET
| RBRACE
+ | QUOTED_STRING_ITEM of (
+# 689 "parsing/parser.mly"
+ (string * Location.t * string * Location.t * string option)
+# 47 "parsing/parser.ml"
+ )
+ | QUOTED_STRING_EXPR of (
+# 687 "parsing/parser.mly"
+ (string * Location.t * string * Location.t * string option)
+# 52 "parsing/parser.ml"
+ )
| QUOTE
| QUESTION
| PRIVATE
| PREFIXOP of (
-# 666 "parsing/parser.mly"
+# 671 "parsing/parser.mly"
(string)
-# 50 "parsing/parser.ml"
+# 60 "parsing/parser.ml"
)
| PLUSEQ
| PLUSDOT
| PERCENT
| OR
| OPTLABEL of (
-# 659 "parsing/parser.mly"
+# 664 "parsing/parser.mly"
(string)
-# 60 "parsing/parser.ml"
+# 70 "parsing/parser.ml"
)
| OPEN
| OF
| MATCH
| LPAREN
| LIDENT of (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 78 "parsing/parser.ml"
+# 88 "parsing/parser.ml"
)
| LETOP of (
-# 624 "parsing/parser.mly"
+# 629 "parsing/parser.mly"
(string)
-# 83 "parsing/parser.ml"
+# 93 "parsing/parser.ml"
)
| LET
| LESSMINUS
| LBRACE
| LAZY
| LABEL of (
-# 629 "parsing/parser.mly"
+# 634 "parsing/parser.mly"
(string)
-# 103 "parsing/parser.ml"
+# 113 "parsing/parser.ml"
)
| INT of (
-# 628 "parsing/parser.mly"
+# 633 "parsing/parser.mly"
(string * char option)
-# 108 "parsing/parser.ml"
+# 118 "parsing/parser.ml"
)
| INITIALIZER
| INHERIT
| INFIXOP4 of (
-# 622 "parsing/parser.mly"
+# 627 "parsing/parser.mly"
(string)
-# 115 "parsing/parser.ml"
+# 125 "parsing/parser.ml"
)
| INFIXOP3 of (
-# 621 "parsing/parser.mly"
+# 626 "parsing/parser.mly"
(string)
-# 120 "parsing/parser.ml"
+# 130 "parsing/parser.ml"
)
| INFIXOP2 of (
-# 620 "parsing/parser.mly"
+# 625 "parsing/parser.mly"
(string)
-# 125 "parsing/parser.ml"
+# 135 "parsing/parser.ml"
)
| INFIXOP1 of (
-# 619 "parsing/parser.mly"
+# 624 "parsing/parser.mly"
(string)
-# 130 "parsing/parser.ml"
+# 140 "parsing/parser.ml"
)
| INFIXOP0 of (
-# 618 "parsing/parser.mly"
+# 623 "parsing/parser.mly"
(string)
-# 135 "parsing/parser.ml"
+# 145 "parsing/parser.ml"
)
| INCLUDE
| IN
| IF
| HASHOP of (
-# 677 "parsing/parser.mly"
+# 682 "parsing/parser.mly"
(string)
-# 143 "parsing/parser.ml"
+# 153 "parsing/parser.ml"
)
| HASH
| GREATERRBRACKET
| FUN
| FOR
| FLOAT of (
-# 607 "parsing/parser.mly"
+# 612 "parsing/parser.mly"
(string * char option)
-# 156 "parsing/parser.ml"
+# 166 "parsing/parser.ml"
)
| FALSE
| EXTERNAL
| ELSE
| DOWNTO
| DOTOP of (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 170 "parsing/parser.ml"
+# 180 "parsing/parser.ml"
)
| DOTDOT
| DOT
| DONE
| DOCSTRING of (
-# 696 "parsing/parser.mly"
+# 705 "parsing/parser.mly"
(Docstrings.docstring)
-# 178 "parsing/parser.ml"
+# 188 "parsing/parser.ml"
)
| DO
| CONSTRAINT
| COMMENT of (
-# 695 "parsing/parser.mly"
+# 704 "parsing/parser.mly"
(string * Location.t)
-# 185 "parsing/parser.ml"
+# 195 "parsing/parser.ml"
)
| COMMA
| COLONGREATER
| COLON
| CLASS
| CHAR of (
-# 587 "parsing/parser.mly"
+# 592 "parsing/parser.mly"
(char)
-# 196 "parsing/parser.ml"
+# 206 "parsing/parser.ml"
)
| BEGIN
| BARRBRACKET
| ASSERT
| AS
| ANDOP of (
-# 625 "parsing/parser.mly"
+# 630 "parsing/parser.mly"
(string)
-# 209 "parsing/parser.ml"
+# 219 "parsing/parser.ml"
)
| AND
| AMPERSAND
let wrap_mksig_ext ~loc (item, ext) =
wrap_sig_ext ~loc (mksig ~loc item) ext
+let mk_quotedext ~loc (id, idloc, str, strloc, delim) =
+ let exp_id = mkloc id idloc in
+ let e = ghexp ~loc (Pexp_constant (Pconst_string (str, strloc, delim))) in
+ (exp_id, PStr [mkstrexp e []])
+
let text_str pos = Str.text (rhs_text pos)
let text_sig pos = Sig.text (rhs_text pos)
let text_cstr pos = Cf.text (rhs_text pos)
}
-# 778 "parsing/parser.ml"
+# 793 "parsing/parser.ml"
module Tables = struct
fun _tok ->
match _tok with
| AMPERAMPER ->
- 121
+ 123
| AMPERSAND ->
- 120
+ 122
| AND ->
- 119
+ 121
| ANDOP _ ->
- 118
+ 120
| AS ->
- 117
+ 119
| ASSERT ->
- 116
+ 118
| BACKQUOTE ->
- 115
+ 117
| BANG ->
- 114
+ 116
| BAR ->
- 113
+ 115
| BARBAR ->
- 112
+ 114
| BARRBRACKET ->
- 111
+ 113
| BEGIN ->
- 110
+ 112
| CHAR _ ->
- 109
+ 111
| CLASS ->
- 108
+ 110
| COLON ->
- 107
+ 109
| COLONCOLON ->
- 106
+ 108
| COLONEQUAL ->
- 105
+ 107
| COLONGREATER ->
- 104
+ 106
| COMMA ->
- 103
+ 105
| COMMENT _ ->
- 102
+ 104
| CONSTRAINT ->
- 101
+ 103
| DO ->
- 100
+ 102
| DOCSTRING _ ->
- 99
+ 101
| DONE ->
- 98
+ 100
| DOT ->
- 97
+ 99
| DOTDOT ->
- 96
+ 98
| DOTOP _ ->
- 95
+ 97
| DOWNTO ->
- 94
+ 96
| ELSE ->
- 93
+ 95
| END ->
- 92
+ 94
| EOF ->
- 91
+ 93
| EOL ->
- 90
+ 92
| EQUAL ->
- 89
+ 91
| EXCEPTION ->
- 88
+ 90
| EXTERNAL ->
- 87
+ 89
| FALSE ->
- 86
+ 88
| FLOAT _ ->
- 85
+ 87
| FOR ->
- 84
+ 86
| FUN ->
- 83
+ 85
| FUNCTION ->
- 82
+ 84
| FUNCTOR ->
- 81
+ 83
| GREATER ->
- 80
+ 82
| GREATERRBRACE ->
- 79
+ 81
| GREATERRBRACKET ->
- 78
+ 80
| HASH ->
- 77
+ 79
| HASHOP _ ->
- 76
+ 78
| IF ->
- 75
+ 77
| IN ->
- 74
+ 76
| INCLUDE ->
- 73
+ 75
| INFIXOP0 _ ->
- 72
+ 74
| INFIXOP1 _ ->
- 71
+ 73
| INFIXOP2 _ ->
- 70
+ 72
| INFIXOP3 _ ->
- 69
+ 71
| INFIXOP4 _ ->
- 68
+ 70
| INHERIT ->
- 67
+ 69
| INITIALIZER ->
- 66
+ 68
| INT _ ->
- 65
+ 67
| LABEL _ ->
- 64
+ 66
| LAZY ->
- 63
+ 65
| LBRACE ->
- 62
+ 64
| LBRACELESS ->
- 61
+ 63
| LBRACKET ->
- 60
+ 62
| LBRACKETAT ->
- 59
+ 61
| LBRACKETATAT ->
- 58
+ 60
| LBRACKETATATAT ->
- 57
+ 59
| LBRACKETBAR ->
- 56
+ 58
| LBRACKETGREATER ->
- 55
+ 57
| LBRACKETLESS ->
- 54
+ 56
| LBRACKETPERCENT ->
- 53
+ 55
| LBRACKETPERCENTPERCENT ->
- 52
+ 54
| LESS ->
- 51
+ 53
| LESSMINUS ->
- 50
+ 52
| LET ->
- 49
+ 51
| LETOP _ ->
- 48
+ 50
| LIDENT _ ->
- 47
+ 49
| LPAREN ->
- 46
+ 48
| MATCH ->
- 45
+ 47
| METHOD ->
- 44
+ 46
| MINUS ->
- 43
+ 45
| MINUSDOT ->
- 42
+ 44
| MINUSGREATER ->
- 41
+ 43
| MODULE ->
- 40
+ 42
| MUTABLE ->
- 39
+ 41
| NEW ->
- 38
+ 40
| NONREC ->
- 37
+ 39
| OBJECT ->
- 36
+ 38
| OF ->
- 35
+ 37
| OPEN ->
- 34
+ 36
| OPTLABEL _ ->
- 33
+ 35
| OR ->
- 32
+ 34
| PERCENT ->
- 31
+ 33
| PLUS ->
- 30
+ 32
| PLUSDOT ->
- 29
+ 31
| PLUSEQ ->
- 28
+ 30
| PREFIXOP _ ->
- 27
+ 29
| PRIVATE ->
- 26
+ 28
| QUESTION ->
- 25
+ 27
| QUOTE ->
+ 26
+ | QUOTED_STRING_EXPR _ ->
+ 25
+ | QUOTED_STRING_ITEM _ ->
24
| RBRACE ->
23
Obj.repr ()
| QUOTE ->
Obj.repr ()
+ | QUOTED_STRING_EXPR _v ->
+ Obj.repr _v
+ | QUOTED_STRING_ITEM _v ->
+ Obj.repr _v
| RBRACE ->
Obj.repr ()
| RBRACKET ->
Obj.repr ()
and default_reduction =
- (16, "\000\000\000\000\000\000\002\221\002\220\002\219\002\218\002\217\002\172\002\216\002\215\002\214\002\213\002\212\002\211\002\210\002\209\002\208\002\207\002\206\002\205\002\204\002\203\002\202\002\201\002\200\002\199\002\198\002\171\002\197\002\196\002\195\002\194\002\193\002\192\002\191\002\190\002\189\002\188\002\187\002\186\002\185\002\184\002\183\002\182\002\181\002\180\002\179\002\178\002\177\002\176\002\175\002\174\002\173\000\000\000\000\000\"\000\182\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\029\001\148\001\127\001\145\001\144\001\143\001\149\001\153\000\000\003\030\001\147\001\146\001\128\001\151\001\142\001\141\001\140\001\139\001\138\001\136\001\152\001\150\000\000\000\000\000\000\000\215\000\000\000\000\001\131\000\000\000\000\000\000\001\133\000\000\000\000\000\000\001\135\001\157\001\154\001\137\001\129\001\155\001\156\000\000\003\028\003\027\003\026\000\000\000\000\000\016\001;\000\000\000\211\000\212\000\015\000\000\000\000\001\179\001\178\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\022\000\000\003\023\000\000\000\000\003\020\000\000\003\019\003\015\002\024\000\000\003\018\000\000\002\025\000\000\000\000\000\000\000\000\000f\000\000\000\000\000c\000\000\000\000\003\r\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\180\001?\000\000\000\000\000\000\000\000\000\000\000\000\002\003\000\000\000\000\000\000\000\000\000\000\000\000\000m\000_\000\000\000\000\000\000\000\000\0009\000\000\000\000\001@\000:\002l\000\000\001\r\000\000\000j\000\000\000\000\000\t\000\b\000\000\000\000\000\000\000\000\002\153\000\000\002K\002L\000\000\002I\002J\000\000\000\000\000\000\000\000\000\000\001P\001O\000\000\002\151\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\246\002\245\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000i\000\000\000\225\000\000\000\000\000\226\000\000\002N\002M\000\000\000\000\000\000\001\161\000\000\000\000\000\029\000\000\000\000\000\000\000\022\000\000\000\000\001h\000\017\000\000\000\000\000\000\000\000\000\000\000\000\001>\000\000\001=\000\000\001<\000\000\003\014\000 \000\000\000\000\000\023\000\018\000\000\000\000\000\000\000\196\000\000\000\000\000\000\000\198\002\"\002\020\000\000\000\026\000\000\002\021\000\000\000\000\001\158\000\000\000\000\000\000\000\n\000\000\000\000\000\000\000\011\002\247\000\000\002\248\000\000\000u\000\000\000\000\000\025\000\000\000\000\000\000\000\027\000\000\000\028\000\000\000\030\000\000\000\000\000\031\002\n\002\t\000\000\000\000\000\000\000\000\000\000\000\000\000]\000\000\002\158\000`\000l\000^\002\147\002\148\001\213\002\150\000\000\000\000\002\155\002H\002\157\000\000\000\000\000\000\002\164\002\161\000\000\000\000\000\000\001\210\001\196\000\000\000\000\000\000\000\000\001\200\000\000\001\195\000\000\001\212\002\170\000\000\001\211\001\203\000\000\000h\000\000\002\163\002\162\000\000\001\206\000\000\000\000\001\202\000\000\000\000\001\198\001\197\000\000\002\160\000\000\002P\002O\000\000\000\000\002,\002\159\002\156\000\000\000\000\000\000\000\000\001\163\001(\001)\002R\000\000\002S\002Q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\236\000\237\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\199\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001Z\000\000\000\000\000\000\000\000\000\000\000\000\0034\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\018\000\000\000\000\002\019\000\000\000\000\001Y\000\000\000\000\000\000\001`\001_\001]\002\006\002\005\000\000\001X\001W\000\000\000\200\000\000\000\000\001I\000\000\000\000\001M\000\000\001\183\001\182\000\000\000\000\001\181\001\180\001L\001J\000\000\001N\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002p\003\031\002u\002s\000\000\000\000\000\000\002\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\146\000\000\002\145\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\224\000\000\000\000\000\000\000\000\000\000\000\000\000\234\001\223\000\235\000\000\000\000\000\000\001j\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\229\000\000\000\230\000\000\000\000\000\000\002}\000\000\000\000\000\000\002X\002W\000\000\000\000\000\000\000\000\002\127\002r\002q\000\000\000\000\000\165\000\000\000\000\000\000\000\000\000\000\000\179\000\000\000\000\000\000\000\164\000\000\000\000\000\000\0023\0022\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\238\000\000\002\224\000\000\003\n\000\000\000\000\003\t\000\000\000\000\000\000\000\000\000\000\000\190\000\189\000\239\000\000\002\225\002\226\000\000\000\000\000k\000\000\002\165\002\149\000\000\002\168\000\000\002\167\002\166\000\000\000\000\000\000\000\000\000\000\000\000\000\243\000\000\000\000\002\012\000\000\000\000\000\000\000\242\000\000\000\000\000\241\000\240\000\000\000\000\000\000\000\000\000\245\000\000\000\000\000\244\000\000\001\209\000\000\000\000\001\220\000\000\000\000\001\222\000\000\000\000\001\218\001\217\001\215\001\216\000\000\000\000\000\000\000\000\000\000\001\019\000\012\000\247\000\000\000\000\000\000\002Z\002Y\000\000\000\000\002h\002g\000\000\000\000\000\000\000\000\002d\002c\000\000\000\000\002&\000\000\000\000\002b\002a\000\000\000\000\002f\002e\002y\000\000\000\000\000\000\000\000\000\000\002^\000\000\000\000\000\000\000\000\000\000\002\\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\b\002\007\000\163\000\000\002]\000\000\000\000\002[\000\000\000\000\002_\000\000\000v\000w\000\000\000\000\000\000\000\000\000\134\000\191\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\192\000\000\000\193\000\194\000\127\000\000\000~\000\000\000\000\001+\000\000\001,\001*\002\014\000\000\000\000\002\015\002\r\000\000\000\000\000\000\000\000\000\000\000\254\000\000\000\000\000\255\000\000\000\000\000\166\000\000\001\001\001\000\000\000\000\000\002\129\002z\000\000\002\138\000\000\002\139\002\137\000\000\002\143\000\000\002\144\002\142\000\000\000\000\002|\002{\000\000\000\000\000\000\001\246\000\000\001\177\000\000\000\000\000\000\002/\001\245\000\000\002\133\002\132\000\000\000\000\000\000\003 \000\000\002j\000\000\002k\002i\000\000\002\131\002\130\000\000\000\000\000\000\002)\002x\000\000\002w\002v\000\000\002\141\002\140\000|\000\000\000\000\000\000\000\000\000{\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000y\000\000\001C\000\000\000\000\000\000\000a\000\000\000\000\000d\000\000\000b\000e\000\000\000\000\000\000\001b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\219\000\000\000\000\000q\000\000\000\222\000\220\000\000\000\000\000\000\000\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\000\000\000\000\001\244\000\000\000\000\000\246\001\175\000\000\000\232\000\233\000\253\000\000\000\000\000\000\000\000\000\000\001\190\001\184\000\000\001\189\000\000\001\187\000\000\001\188\000\000\001\185\000\000\000\000\001\186\000\000\001|\000\000\000\000\000\000\001{\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\t\002\239\000\000\000\000\002\238\000\000\000\000\000\000\000\000\000\000\001\229\000\000\000\000\000\000\000\000\000\000\000\000\002\244\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001l\000\000\001\235\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\223\000\000\000\000\0024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001~\000\000\000\000\000\000\001}\000\000\000\000\000\000\000\000\000\000\001R\000\000\001Q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\011\002B\000\000\000\000\000\000\002@\000\000\000\000\000\000\002?\000\000\001E\000\000\000\000\000\000\000\000\002E\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003(\000\000\000\000\000\000\000\188\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000>\000\000\000\000\000\000\000\000\001g\000\000\001f\000\000\000\000\000\000\000\000\000A\000\000\000\000\000\000\001\242\000\000\001\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000B\000\000\000\000\000\000\000[\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\\\000G\000\000\000\000\000\000\000H\000F\000\000\000K\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000C\000\000\000J\000I\000\000\000D\000E\000\000\001\028\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\007\000Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000W\000\000\000Y\000X\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\005\002F\0028\000\000\002>\0029\002D\002C\002A\001\022\000\000\0026\000\000\000\000\000\000\000\000\000\000\002\003\000\000\000\000\001\015\002:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001w\001s\000\000\000\000\000\000\000\205\000\000\000\000\001\249\002\003\000\000\000\000\001\017\001\247\001\248\000\000\000\000\000\000\000\000\000\000\001z\001v\001r\000\000\000\000\000\206\000\000\000\000\001y\001u\001q\001o\002;\0027\002G\001\021\001\226\0025\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003#\000\000\000\000\003%\000\000\000.\000\000\000\000\003+\000\000\003*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\"\000\000\000\000\003$\000\000\000\000\000\000\001\237\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001:\000\000\000\000\0018\0016\000\000\000/\000\000\000\000\003.\000\000\003-\000\000\000\000\000\000\0014\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0019\000\000\000\000\0017\0015\000\000\000\000\000\000\0001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000Q\000\000\000\000\000\000\000\000\000\000\000\000\000+\000\000\000\000\000P\000\000\000)\000\250\000\000\0008\000%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\248\000\000\000O\000N\000\000\000\000\000T\000S\000\000\000\000\001\165\000\000\000-\000\000\000\000\000\000\000,\000\000\000\000\000\000\0000\000\000\000R\000U\000\000\0002\0003\000\000\001\030\000\000\000\000\000\000\000\000\000\000\000\000\0006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\003\002\242\002\233\000\000\000\000\002\237\002\222\002\232\002\241\002\240\001\026\000\000\000\000\002\230\000\000\002\234\002\231\002\243\001\225\000\000\000\000\002\228\000\000\000\186\002\227\000\000\000\000\000\217\000\000\000\000\001\025\001\024\000\000\001G\001F\000\000\000\000\002\169\002\152\000\000\000;\000\000\000\000\000<\000\000\000\000\000\138\000\137\002\136\000\000\002\135\002\134\002t\000\000\000\000\000\000\000\000\002m\000\000\002o\000\000\002n\000\000\002U\002T\000\000\002V\000\000\000\000\000\130\000\000\000\000\001\234\000\210\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\184\000\000\002\236\001\254\001\255\001\250\001\252\001\251\001\253\000\000\000\000\000\000\000\185\000\000\000\000\002\003\000\000\000\209\000\000\000\000\000\000\000\000\002\235\000\000\000\183\000\000\000\000\000\000\000\000\0013\001-\000\000\000\000\001.\000\021\000\000\000\020\000\000\000\000\000\197\000\000\000\000\000\000\000\024\000\019\000\000\000\000\000\000\000\r\000\000\000\000\000\000\000\000\001x\001t\000\000\001p\003\012\000\000\002\003\000\000\000\208\000\000\000\000\000\000\000\000\002=\002\002\002\000\002\001\000\000\000\000\000\000\002\003\000\000\000\207\000\000\000\000\000\000\000\000\002<\000\000\001T\001S\000\000\000\014\000\000\003&\000\000\000#\000\000\000\000\000\000\000\000\000\133\000\000\000\213\000\001\000\000\000\000\000\216\000\002\000\000\000\003\000\000\001\191\000\000\000\000\001\192\000\004\000\000\000\000\001\193\000\005\000\000\000\000\000\000\002\255\002\250\002\251\002\254\002\252\000\000\000\000\003\003\000\006\000\000\003\002\000\000\001 \000\000\000\000\003\000\000\000\003\001\000\000\000\000\000\000\000\000\001$\001%\000\000\000\000\001#\001\"\000\007\000\000\000\000\000\000\003\025\000\000\003\024")
+ (16, "\000\000\000\000\000\000\002\247\002\246\002\245\002\244\002\243\002\198\002\242\002\241\002\240\002\239\002\238\002\237\002\236\002\235\002\234\002\233\002\232\002\231\002\230\002\229\002\228\002\227\002\226\002\225\002\224\002\197\002\223\002\222\002\221\002\220\002\219\002\218\002\217\002\216\002\215\002\214\002\213\002\212\002\211\002\210\002\209\002\208\002\207\002\206\002\205\002\204\002\203\002\202\002\201\002\200\002\199\000\000\000\000\000*\000\186\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0035\001\168\001\147\001\165\001\164\001\163\001\169\001\173\000\000\0036\001\167\001\166\001\148\001\171\001\162\001\161\001\160\001\159\001\158\001\156\001\172\001\170\000\000\000\000\000\000\000\220\000\000\000\000\001\151\000\000\000\000\000\000\001\153\000\000\000\000\000\000\001\155\001\177\001\174\001\157\001\149\001\175\001\176\000\000\0034\0033\0037\000\000\000\000\000\024\001B\000\188\000\000\000\216\000\217\000\023\000\000\000\000\001\199\001\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003/\000\000\0030\000\000\000\000\003-\000\000\003,\003(\0022\000\000\003+\000\000\0023\000\000\000\000\000\000\000\000\000j\000\000\000\000\000h\000\000\000\000\001@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\184\001N\000\000\000\000\000\000\000\000\000\000\000\000\002\029\000\000\000\000\000\000\000\000\000\000\000\000\000e\000\000\000\000\000\000\000\000\001L\000\000\000\000\001O\001M\001U\000A\002\134\000\000\001\018\000\000\000\000\000\000\000\015\000\014\000\000\000\000\000\000\000\000\002\179\000\000\002e\002f\000\000\002c\002d\000\000\000\000\000\000\000\000\000\000\001e\001d\000\000\002\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\223\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\016\003\015\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000g\000\000\000\231\000\000\002h\002g\000\000\000\000\000\000\001\181\000\000\000\000\000%\000\000\000\000\000\000\000\000\000\000\001T\000\000\001S\000\000\001C\001R\000\000\001A\000b\000\030\000\000\000\000\001|\000\025\000\000\000\000\000\000\000\000\003'\000(\000\000\000\000\000\031\000\026\000\000\000\000\000\000\000\201\000\000\000\000\000\000\000\203\002<\002.\000\000\000\"\000\000\002/\000\000\000\000\001\178\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\017\003\017\000\000\003\018\000\000\000y\000\000\000\000\000!\000\000\000\000\000\000\000#\000\000\000$\000\000\000&\000\000\000\000\000'\002$\002#\000\000\000\000\000\000\000\000\000\000\000\000\000c\000\000\002\184\000f\000i\000d\002\173\0038\002\174\001\239\002\176\000\000\000\000\002\181\002b\002\183\000\000\000\000\000\000\002\190\002\187\000\000\000\000\000\000\001\236\001\222\000\000\000\000\000\000\000\000\001\226\000\000\001\221\000\000\001\238\002\196\000\000\001\237\000q\001\229\000\000\000o\000\000\002\189\002\188\000\000\001\232\000\000\000\000\001\228\000\000\000\000\001\224\001\223\000\000\002\186\000\000\002j\002i\000\000\000\000\002F\002\185\002\182\000\000\000\000\000\000\000\000\001\183\001-\001.\002l\000\000\002m\002k\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\241\000\242\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\204\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001o\000\000\000\000\000\000\000\000\000\000\000\000\003M\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002,\000\000\000\000\002-\000\000\000\000\001n\000\000\000\000\000\000\001K\001t\001J\001r\002 \002\031\000\000\001m\001l\000\000\000\205\000\000\000\000\001^\000\000\000\000\001b\000\000\001\203\001\202\000\000\000\000\001\201\001\200\001a\001_\000\000\001c\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\138\001P\002\143\002\141\000\000\000\000\000\000\002\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\172\000\000\002\171\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\250\000\000\000\000\000\000\000\000\000\000\000\000\000\239\001\249\000\240\000\000\000\000\000\000\001~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\234\000\000\000\235\000\000\000\000\000\000\002\151\000\000\000\000\000\000\002r\002q\000\000\000\000\000\000\000\000\0039\002\153\002\140\002\139\000\000\000\000\000\169\000\000\000\000\000\000\000\000\000\000\000\183\000\000\000\000\000\000\000\168\000\000\000\000\000\000\002M\002L\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\243\000\000\002\250\000\000\003$\000\000\000\000\003#\000\000\000\000\000\000\000\000\000\000\000\195\000\194\000\244\000\000\002\251\002\252\000\000\000\000\000p\000\000\002\191\002\175\000\000\002\194\000\000\002\193\002\192\000\000\000\000\000\000\000\000\000\000\000\000\000\248\000\000\000\000\002&\000\000\000\000\000\000\000\247\000\000\000\000\000\246\000\245\000\000\000\000\000\000\000\000\000\250\000\000\000\000\000\249\000\000\001\235\000\000\000\000\001\246\000\000\000\000\001\248\000\000\000\000\001\244\001\243\001\241\001\242\000\000\000\000\000\000\000\000\000\000\001\024\000\018\000\252\000\000\000\000\000\000\002t\002s\000\000\000\000\002\130\002\129\000\000\000\000\000\000\000\000\002~\002}\000\000\000\000\002@\000\000\000\000\002|\002{\000\000\000\000\002\128\002\127\002\147\000\000\000\000\000\000\000\000\000\000\002x\000\000\000\000\000\000\000\000\000\000\002v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\"\002!\000\167\000\000\002w\000\000\000\000\002u\000\000\000\000\002y\000\000\000z\000{\000\000\000\000\000\000\000\000\000\138\000\196\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197\000\000\000\198\000\199\000\131\000\000\000\130\000\000\000\000\0010\000\000\0011\001/\002(\000\000\000\000\002)\002'\000\000\000\000\000\000\000\000\000\000\001\003\000\000\000\000\001\004\000\000\000\000\000\170\000\000\001\006\001\005\000\000\000\000\002\155\002\148\000\000\002\164\000\000\002\165\002\163\000\000\002\169\000\000\002\170\002\168\000\000\000\000\002\150\002\149\000\000\000\000\000\000\002\016\000\000\001\197\000\000\000\000\000\000\002I\002\015\000\000\002\159\002\158\000\000\000\000\000\000\001Q\000\000\002\132\000\000\002\133\002\131\000\000\002\157\002\156\000\000\000\000\000\000\002C\002\146\000\000\002\145\002\144\000\000\002\167\002\166\000\128\000\000\000\000\000\000\000\000\000\127\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000}\000\000\001X\000\000\000\000\000\000\000k\000\000\000\000\000l\000\000\000\000\000\000\000\000\001v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\225\000\000\000\000\000u\000\000\000\228\000\226\000\000\000\000\000\000\000\207\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000~\000m\000\000\000\000\002\014\000\000\000\000\000\251\001\195\000\000\000\237\000\238\001\002\000\000\000\000\000\000\000\000\000\000\001\210\001\204\000\000\001\209\000\000\001\207\000\000\001\208\000\000\001\205\000\000\000\000\001\206\000\000\001\144\000\000\000\000\000\000\001\143\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001s\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\014\003\t\000\000\000\000\003\b\000\000\000\000\000\000\000\000\000\000\001\255\000\000\000\000\000\000\000\000\000\000\000\000\003\014\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\128\000\000\002\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\249\000\000\000\000\002N\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\146\000\000\000\000\000\000\001\145\000\000\000\000\000\000\000\000\000\000\001g\000\000\001f\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\016\002\\\000\000\000\000\000\000\002Z\000\000\000\000\000\000\002Y\000\000\001Z\000\000\000\000\000\000\000\000\002_\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003A\000\000\000\000\000\000\000\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000E\000\000\000\000\000\000\000\000\001{\000\000\001z\000\000\000\000\000\000\000\000\000H\000\000\000\000\000\000\002\012\000\000\002\011\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000I\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000N\000\000\000\000\000\000\000O\000M\000\000\000R\000\000\000\000\000\000\000\000\000\000\000G\000\000\000\000\000\000\000\000\000\000\000\000\000J\000\000\000Q\000P\000\000\000K\000L\000\000\001!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\012\000a\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000^\000\000\000`\000_\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\n\002`\002R\000\000\002X\002S\002^\002]\002[\001\027\000\000\002P\000\000\000\000\000\000\000\000\000\000\002\029\000\000\000\000\001\020\002T\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\139\001\135\000\000\000\000\000\000\000\210\000\000\000\000\002\019\002\029\000\000\000\000\001\022\002\017\002\018\000\000\000\000\000\000\000\000\000\000\001\142\001\138\001\134\000\000\000\000\000\211\000\000\000\000\001\141\001\137\001\133\001\131\002U\002Q\002a\001\026\001\252\002O\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003<\000\000\000\000\003>\000\000\0006\000\000\000\000\003D\000\000\003C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003;\000\000\000\000\003=\000\000\000\000\000\000\002\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001?\000\000\000\000\001=\001;\000\000\0007\000\000\000\000\003G\000\000\003F\000\000\000\000\000\000\0019\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001>\000\000\000\000\001<\001:\000\000\000\000\000\000\0009\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\254\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000X\000\000\000\000\000\000\000\000\000\000\000\000\0003\000\000\000\000\000W\000\000\0001\000\255\000\000\000@\000-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\253\000\000\000V\000U\000\000\000\000\000[\000Z\000\000\000\000\001\185\000\000\0005\000\000\000\000\000\000\0004\000\000\000\000\000\000\0008\000\000\000Y\000\\\000\000\000:\000;\000\000\001#\000\000\000\000\000\000\000\000\000\000\000\000\000>\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\b\003\012\003\003\000\000\000\000\003\007\002\248\003\002\003\011\003\n\001\031\000\000\000\000\003\000\000\000\003\004\003\001\003\r\001\251\000\000\000\000\002\254\000\000\000\191\002\253\000\000\000\000\000\222\000\000\000\000\001\030\001\029\000\000\001\\\001[\000\000\000\000\002\195\002\178\000\000\000B\000\000\000\000\000C\000\000\000\000\000\142\000\141\002\162\000\000\002\161\002\160\002\142\000\000\000\000\000\000\000\000\002\135\000\000\002\137\000\000\002\136\000\000\002o\002n\000\000\002p\000\000\000\000\000\134\000\000\000\000\002\004\000\215\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\189\000\000\003\006\002\024\002\025\002\020\002\022\002\021\002\023\000\000\000\000\000\000\000\190\000\000\000\000\002\029\000\000\000\214\000\000\000\000\000\000\000\000\003\005\000\000\000\187\000\000\000\000\000\000\000\000\0018\0012\000\000\000\000\0013\000\029\000\000\000\028\000\000\000\000\000\202\000\000\000\000\000\000\000 \000\027\000\000\000\000\000\000\000\021\000\000\000\000\000\000\000\000\001\140\001\136\000\000\001\132\003&\000\000\002\029\000\000\000\213\000\000\000\000\000\000\000\000\002W\002\028\002\026\002\027\000\000\000\000\000\000\002\029\000\000\000\212\000\000\000\000\000\000\000\000\002V\000\000\001i\001h\000\000\000\022\000\000\003?\000\000\000+\000\000\000\000\000\000\000\000\000\137\000\000\000\218\000\001\000\000\000\000\000\221\000\002\000\000\000\000\000\000\001E\001F\000\003\000\000\000\000\000\000\000\000\001H\001I\001G\000\019\001D\000\020\000\000\001\211\000\000\000\004\000\000\001\212\000\000\000\005\000\000\001\213\000\000\000\000\001\214\000\006\000\000\000\007\000\000\001\215\000\000\000\b\000\000\001\216\000\000\000\t\000\000\001\217\000\000\000\000\001\218\000\n\000\000\000\000\001\219\000\011\000\000\000\000\000\000\000\000\000\000\003\025\003\020\003\021\003\024\003\022\000\000\003\029\000\012\000\000\003\028\000\000\001%\000\000\000\000\003\026\000\000\003\027\000\000\000\000\000\000\000\000\001)\001*\000\000\000\000\001(\001'\000\r\000\000\000\000\000\000\0032\000\000\0031")
and error =
- (122, "'\225 \022*\183\204\207@P?\144\000\0148\b\216@\005\194\141\241'\208\004\015\128\000\001\142\007\223dB\011\248\212\000\019\007\007\184\226\192\160\208\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\254\182mf\235\252\205\255\005G\248\132A\231\129\247\217\016\130\2545\000\004\193\193\2388\176(4\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0026\016\001`\163|I\244\001\003\224\000\000c\129\247\217\016\130\2545\000\004\193\193\2388\176(4'\225\"V*\183\204\207@P?\128\000\0308\000\000\000\000@\000\192\004\000\000\000\000\000\000\000\000\000\000\000\000\0000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\128\000\128\031\128\176\144\000\015\136\128A\000@\162\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000(\000\000\000\000\000\000\000\000\000\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\128\000\b\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\128\000\b\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\128\000\b\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\192\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\192@\131\023\b\000\004\000\000\000\000\000\000@\016\000@ \193\004\000\000\016\000\000\000\000\000\016\004\000\000\b0A\000\000\004\000\000\000\000\000\004\001\000\000\002\012\016\000\000\001\000\000\000\000\000\196\128*\000 \194Hp\000D\001\216@\136\001! \b\000\b \002\020\000\016\000b\000\002\000\bH\002\000\002\b\000\132\000\004\000\024\128\000\128\000\012\000\002\012\016L\000@\000\000\000\000\000\000\000\003\000\000\130\004\019\000\016\000\000\000\000\000\000\000\000\192\000 \129\004\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\002\b\000L\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000 \128\004\000\000\000\000\000\000\000\000\000\000 \000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\b \001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000! \b\130\b \002\024\000\016\000v\001\018\000@2\000\014\004\0001p\160\000@ \b\000\004\002\018\000\136\000\194\t!\192\001\016\006a\016a\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200\0000\016\000\197\194\128\001\000\128 \000\016\0000\000\140\004\b1p\128\000@\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197\128\187\000 \201Hp0D\129\216\005\152E\128\192\000 \000\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\002\000\000\012\\ \000\018\000\002\000\000\000\001\000\016\000\000\001\000\000\000\004\128\000\000\016\000\000\192\0000\016\000\197\194\000\001\000\000\000\000\000\000\016\000\000\000\000\016\000\000\000\000\000\000\000\000\002\020\002F\000\001$!\192\192\018\001!\018\000\016}\246D \191\141@\0010p{\142,\n\r\t\248H\149\138\173\2433\208\020\015\224\000\007\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\131\004\019\000\016\000\000\000\000\000\000\000\000\192\000 \129\004\192\004\000\000\000\000\000\000\000\0000\000\b A0\000\000\000\000\000\000\000\000\000\012\000\002\b\000L\000\000\000\000\000\000\000\000\000\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000! \b\130\b \018\024\000\017\000v\001\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\018\000\136\000\130\001!\128\001\016\006`\016 \004}\246D \191\141@\0010p{\142,\n\r\t\248H\149\138\173\2433\208\020\015\224\000\007\142\0026\016\001p\163|I\244\001\003\224\000\000c\128\141\132\000X(\223\018}\000@\248\000\000\024\224#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\132\000@\b\012\0189\000\000\024\000\000\024\192\001\000\000\001\000\001\000\016\000\000\000\000\000\000\000\000@\000\000\000\000@\004\000\000\000\000\000\000\000\000\016\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000@\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000+\250\221\253\155\239\247\255\252\029?\230!\003\158@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\141\134 ~*\223R=>b\249\004\001\154\235\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 HB\004\000\128\193#\144\000\001\128\000\001\140\0026\016\001`\163|H\244\001\003\224\000\000s\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\000\000\000@\002\130\020\012\000\000\002\001\000\000\b@\000\000\000\000\160\133\003\000\000\000\128@\000\002\016\000\000\000\000(!\000\192\000\000 \016\000\000\003!\000\002\000\019\004\139@\004\006\128\000\004\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\131!\136\031\128\179\148\139O\140\134\193\000d\178\224\000\002\000\000\000\000\000\016\000\001\000\000\000\000\b0\000\000\016\000\000\001\000\000\000\000\000\000\000\000\012\000\000\000\000\000\000@\000\000\000\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\016\000\000 \193\000\000\000\016\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\001\002\000\000\000\002\004\016\000\000@\000\000\000\000\000@\128\000\000\000\129\000\000\000\016\000\000\000\000\n~\018\001b\171|\205\244\005\003\248\128\000\227\130\159\132\128X\170\2233=\001@\254 \0008\224\167\225\"\022*\183\204\207@P?\152\000\0148\000@\128\000@\000\129\004\000\000\016\000\000\000\b\000\016 \000\016\000 A\000\000\004\000\000\000\000\000\004\b\000\000\000\b\016@\000\001\000\000\000\000\000\001\002\000\000\000\002\004\000\000\000@\000\000\000\000\001@\128\000\000\000\129\000\000\000\016\000\000\000\000\0026\016\001`\163|I\244\001\003\224\000\000c\128\141\132\000X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0026\016\001p\163|I\244\001\003\224\000\000c\128\141\132\000X(\223\018}\000@\248\000\000\024\224#a\000\022\n7\196\143@\016>\000\000\00681on\215\248\190\223?\191\251a\247\219\127\252\2426\016\001`\163|H\244\001\003\224\000\000c\128\012\132\000\b\000L\018-\000\016\024\000\000\016@\003!\000\002\000\019\004\139@\004\006\128\000\005\016\000\200@\128\128\004\193\"\208\001\001\160\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\016\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000D\000\000\000\000\000\000\000\001\000\000@\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\192\0000\016\000\197\194\000\001\000\000\000\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\003\001\000\012\\ \000\016\000\000\000\000@\003\000\002\192@\003\023\b\000\004\000\000\000\000P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\012\004\0001p\128\000@\000\000\000\001\000\012\000\003\001\000\012\\ \000\016\000\000\000\001@\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\012\004\0001p\128\000@\000\000\000\001\000\004\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012H\003\176\002\012\132\135\003\004H\029\128X\132X\012\000\003\001\000\012\\ \000\016\000\000\000\000\000\196\128\187\000 \200Hp0D\129\216\005\136E\128\192\000 \000\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\004\000\000\002\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\128\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197\128\187\000 \201Hp0D\129\216\005\136E\128@\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\128\000\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\0000\000\012\004\0001p\128\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197\128\187\000 \201Hp0D\129\216\005\136E\128\192\000 \000\000\197\194\000\001\000\000\000\000\000\012X\011\176\002\012\148\135\003\004H\029\128X\132X\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \001\000\000\001\000\000\b\000\000\000\004\000\012\000\003\001\000\012\\ \000\016\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\192\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000 \000\000\000\001\000\000\b\000\000\000\004\b\012\000\003\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\004\000\000 \000\000\000\017 \000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\001\000\000\b\000\000\000\004H\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\016\000\000\128\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012H\003\176\002\012\132\135\003\004H\029\128X\132P\000\000\b\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\0000\000\012\004\0001p\128\000@\000\000\000\001\000\000\000\b\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\002\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000 \000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\001\016\000\000\000\001\000\000\000\004\000\000\000\002\000\000D\000\000\000\000\000\000\000\001\000\000\000\000\003!\000\002\000\019\004\139@\004\006\128\000\004\016\000\200@\000\192\004\193&\144\001\001\128\000\001\004\0002\016\000 \0010I\164\000@`\000\000A\000\012\132\000\b\000L\018)\000\016\024\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t2\145\180$\0050I\172\000@e\b\027U@\000\004\000\b\000@\000\001\000\000\016\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002L\164m\t\001L\018o\000\016\027A\006\213P\001\000\000\000\000\002\000\138\000\000\000\000\000\000\000 \200B\000\128\004\193\"\208\001\001\160\000\t\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003!\000\003\000\019\004\155@\004\006\128\000\004\016\000\200@\000\128\004\193&\208\001\001\160\000\001\004\0002\016\000 \0010H\180\000@h\000\000A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\000\006\192\000\016\000\004\000\000\000\020\000LQ\0002\016\000 \0010H\180\000@h\000\000A\002@\000l\000\001\000\000@\000\000\001@\004\197\016\131!\000\002\000\019\004\139@\004\006\128\000\004\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\001\176\000\004\000\001\000\000\000\005\000\019\020@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\147!\027\002\000S\004\155@\004\006\208\0015T\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002L\132l\b\001L\018m\000\016\027@\004\213P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\b\000\000\000\000\016\000\000\000\000\001 D\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\012\132\000\b\000L\018-\000\016\026\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\000\006\192\000\016\000\004\000\000\000\020\000LQ\b2\016\000 \0010H\180\000@h\000\000A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\000\027\000\000@\000\016\000\000\000P\0011D \000\000\000\000\000\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003!\002\002\000\019\004\139@\004\006\128\000\004\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\004\128\000\000\000\004\000\000\000\000\000HQ\b2\016 \0010H\180\000@h\000\000Q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\001\016\000\000\000\001\000\000\000\000\000\018\004B\000\000D\000\000\000\000\000\000\000\000\000\000\000\000\131\000\001\000\000\001\000\000\000\000\000\000\000\000\000 \000\004@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\202@\016\144\004\193&\176\001\001\144\000M\021\000\000\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000@\000\016\000\000\192\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000\128\000\000\000\001\000\000\000\004\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000@\000\000\000\b\216@\005\130\141\241#\208\004\015\128\000\001\142\0002\016@2\t0I\180\000@h\000\000A\000\004\b\000\004\000\b\016@\000\001\000\000\000\000\128\001\002\000\001\000\002\004\016\000\000@\000\000\000\000\000@\128\000\000\000\129\004\000\000\016\000\000\000\000\000\016 \000\000\000 @\000\000\004\000\000\000\000\000\000\000\000\000\000\b\000@\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\192\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\001\000@\000\000\131\004\000\000\000@\000\000\000\000\000@\016\000\000 \193\000\000\000\016\000\000\000\000\000\000\000\000\000\000 \001\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000B\000\000\000\000\000\000\000\000\000\000@\016\000\000 \193\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\018\000\168\000\131\001!\192\001\016\007`\002 \004\000\128\000\000\000\128\000\000\000\000\000\000\000\000\000\000\192\000 \128\004\192\000\000\000\000\000\000\000\000\000\016\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001\000\000\003\000\000\224@\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\012\004\0001p\128\000@\000\000\000\000\003\018\000\168\000\131\001!\192\001\016\007`\002 \020\003\000\000\192@\003\023\b\000\004\000\000\000\000\0001 \n\128\b0\018\028\000\017\000v\001\"\001LH\002\160\002\012\004\135\000\004@\029\128H\128\016\012\000\003\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000@\000\000\000\000\192\0000\016\000\197\194\000\001\000\000\000\000\000\012H\002\160\002\012\004\135\000\004@\029\128H\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\016\016\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\003\018\000\168\000\131\t!\192\001\016\007a\002 \004\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\012H\002\160\002\012$\135\000\004@\029\132\b\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\128*\000 \192Hp\000D\001\216\000\136\001\000 \000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\001\000\000\002\012\016\000\000\001\000\000\000\000\000\196\128*\000 \192Hp\000D\001\216\000\136\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\004\000\000\000\004\000\000\000\000\004\000\000\000\000\000\000\000\000\000\196\128*\000 \194Hp\000D\001\216@\136\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\000\128\000\004\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\002\000\000\016\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\b\000\000\000\000\000\000\000\000\000\001\002\000\000\000\002\004\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012H\002\160\002\012$\135\000\006@\029\128\t\128\016\020\b \000\000\b\016\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\002\000\000\000\128\004\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000@\000\000\131\004\000\000\000@\000\000\000\0000\000\002\000\000\016\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012H\002\160\002\012$\135\000\006@\029\132\t\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\016\000 \000\000\000\000\000\b\216@\005\130\141\241#\208\004\015\128\000\001\142\0026\016!`\163|H\244\001\003\224\000\000c\128\000\000\000\000\000\004\000\000\000\004\000\000\000\000\000\128\000\016\000\000\000\000\000\000\001\000@\000\000\000\b\216@\005\130\141\241#\208\004\015\128\000\001\142\000\018\016\001\000 0H\228\000\000`\000\000c\003\000\000D\000\000\000\000\000\0000\001\005\002@\000#a\000\023\n7\196\159@\016>\b\000\0068\b\216@\005\130\141\241'\208\004\015\130\000\001\142\0026\016\001`\163|H\244\001\003\224\128\000c\128\004\132\000D\b\012\018y\000\000\024\000\000\024\192\001!\000\016\002\003\004\158@\000\006\000\000\0060\000H@\004\000\128\193#\144\000\001\128\000\001\140\000\018\016\001\000 0H\228\000\000`\000\000c\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\022\246\237\127\139\237s\251\255\182\031}\183\255\223\001\000\000\000\000\003\000\142\000\000\000\000\000\000\000(\216b\007\226\173\245#\211\230/\144@\025\174\176\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\141\132 X(\223\018=\000@\248\000\000\024\224\163a\b\022\n7\196\143@\016>\000\000\0068 @\128\000@\000\129\004\000\000\016\000\000\000\000\000\016 \000\000\000 A\000\000\004\000\000\000\000\000\004\b\000\000\000\b\016\000\000\001\000\000\000\000\000\000\000\000\000\000\002\000\016\000\000\000\000\000\016\000 @\016\000\000 \193\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000 \000\001\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000(\216B\005\130\141\241#\208\004\015\128\000\001\142\n6\016\129`\163|H\244\001\003\224\000\000c\130\012\132 \b\000L\018-\000\016\024\000\000\016@\000\000\000\000\000\000\000\016\000\000\000@\0010D\000\192\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\004\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224#a\000\023\n7\196\159@\016>\000\000\0068\b\216@\005\130\141\241'\208\004\015\128\000\001\142\0026\016\001`\163|H\244\001\003\224\000\000c\128\012\132\000\012\000L\018m\000\016\026\000\000\017@\003!\000\002\000\019\004\155@\004\006\128\000\004P\000\200@\000\128\004\193\"\208\001\001\160\000\001\020\0002\016\000 \0010H\180\000@h\000\000A\000@\000\000\000\001\000\000@\000\000\000\000\004\129\016#a\000\022\n7\196\143@\016>\000\000\0068\000\202@\016\208\004\193&\176\001\001\128\000\001\004\0002\144\004$\0010I\172\000@`\000\000A\000\012\164\001\t\000L\018+\000\016\024\000\000\016@\002\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0002\016\000 \0010H\180\000@h\000\000A\000\000\000 \000\000\000\000@\000\000\001\000\004\193\016\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\002\000\000\000\000\004\000\000\000\016\000\000\000\000\000\000\128\000\000\000\000\000\000\000\004\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\014\134 ~\002\206R->2\027\004\001\146\203\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000@\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\003)\000B@S\004\138\192\004\006\000\000\020\016\b\216@\005\130\141\241#\208\004\015\128\000\001\142\0002\016\0000\0010I\180\000@h\000\000A\000\012\132\000\b\000L\018m\000\016\026\000\000\016@\003!\000\002\000\019\004\139@\004\006\128\000\004\016\000\000\000\000\000\000\000\004\000\000\000\016\000H\017\0026\016\001`\163|H\244\001\003\224\000\000c\128\004\132\000D\b\012\018y\000\000\024\000\000\024\192\001!\000\016\002\003\004\158@\000\006\000\000\0060\000H@\004\000\128\193#\144\000\001\128\000\001\140\012IK\176\250\015\133\135\003\254\216\029\246\223\156<\004\132\000@\b\012\0189\000\000\024\000\000\024\192\197\189\187_\226\251\\\254\255\237\135\223m\255\247\192\000\000\000\000\000\128\002\128\000\000\000\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\128\141\132\000X(\223\018=\000@\248\000\000\024\224\197\189\187_\226\251\\\254\255\237\135\223m\255\243\192\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000H@\004\000\128\193#\144\000\001\128\000\001\140\012[\219\181\254/\181\207\239\254\216}\246\223\255|\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\192\002\128\000\000\000\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\130\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\197\189\187_\226\251\\\254\255\237\135\223m\255\243\241%.\195\232>\022\028\015\251`w\219~p\240\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000B6\016\001`\163|H\244\001\003\224\000\000c\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012[\219\181\254/\181\207\239\254\216}\246\223\255?\018R\236>\131\225a\192\255\182\007}\183\231\015#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\127[\177\250\175\253\207\247\255[\253\226\223\255\189\247\217\016\130\2545\000\004\193\193\2388\176(4#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\012\132\000\b\000L\018m\000\016\024\000\000\016@\003!\000\002\000\019\004\139@\004\006\000\000\004\016\000\202@\016\144\004\193&\176\001\001\144\000m\021\b:\024\129\248\0119H\180\248\200l\016\006K,\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\202@\016\144\004\193\"\176\001\001\144\000%\004\0002\016\000 \0010H\164\000@`\000\000A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b0\000\012\004\0001p\128\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\025\000\000\000\000\016\000\000\000@\000\000\000 \192\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000d\000\000\000\000@\000\000\001\000\002\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000 \000\006@\000\000\000\004\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\164\001\t\000L\018+\000\016\025\000\002P@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\128\000\000\000\000\004\000\000@\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\002\000\000\000\000\004\000\000\000\000\000L\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\131\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\128\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \224\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000@\000\000\000@\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\003\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000@\000\000\000\b\216@\005\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\004\193\016\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000@\001 D\b\216@\005\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\012\132\000\b\000L\018-\000\016\026\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000H\017\b2\016\000 \0010H\180\000@h\000\000A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000@\001 D \200@\000\128\004\193\"\208\001\001\160\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\004\129\016\128\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000H\017\0002\016\000 \0010H\180\000@h\000\000A\000\000\000\000\000\000\000\000@\000\000\001\000\004\129\016\132\128\"\000 \128H`\000d\001\152\000\b\001! \b\128\b\"\018\024\012\025\000f\001\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0001%.\195\232>\022\028\015\249`w\139~p\2426\016\001`\163|H\244\001\003\224\000\000c\130\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\130\000\002\004>\000\192@@>\002\001\000\005\130\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\b\000(\000\000\000\000\000\000\000#a\000\022\n7\196\143@\016>\000\000\0068 \000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\155\015\1280\016\016\015\128\128@\001a\128\232\216B\197\130\141\241#\208\004\015\128\000\001\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224\128\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001!\000\016\002\003\004\142@\000\006\000\000\00601on\215\248\190\215?\191\251a\247\219\127\253\240\000\000\000\000\000 \000\160\000\000\000\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224\128\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012[\219\181\254/\183\207\239\254\216}\246\223\255<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197\189\187_\226\251|\254\255\237\135\223m\255\243\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156<\141\132\000X(\223\018=\000@\248\000\000\024\224\000\000\001\000\000\000\000\000\000\000\000\000\000\000\0001on\215\248\190\223?\191\251a\247\219\127\252\2426\016\001`\163|H\244\001\003\224\000\000c\131\018R\236>\131\225a\192\255\150\007x\183\231\015\128\000\145\015\1280\016\016\015\128\128@\001`\128\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\0000\000\160\000\000\000\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224\128\000\b\000\000\000\000\000\000\000\000\000\000\000\0001on\215\248\190\223?\191\251a\247\219\127\252\2426\016\001`\163|H\244\001\003\224\000\000c\131\018R\236>\131\225a\192\255\150\007x\183\231\015#a\000\022\n7\196\143@\016>\000\000\0068 \000\000\128\000\000\000\000\000\000\000\000\000\000\000\012[\219\181\254/\183\207\239\254\216}\246\223\255<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\b\000\b\016\248\003\001\001\000\248\b\004\000\022\b\015\022\246\237\127\139\237\243\251\255\182\031}\183\255\207#a\000\022\n7\196\143@\016>\000\000\00681%.\195\232>\022\028\015\249`w\139~p\240\000\000\000\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\b\000(\000\000\000\000\000\000\000#a\000\022\n7\196\143@\016>\000\000\0068 \000\002\000\000\000\000\000\000\000\000\000\000\000\000\012[\219\181\254/\183\207\239\254\216}\246\223\255<\141\132\000X(\223\018=\000@\248\000\000\024\224\196\148\187\015\160\248Xp?\229\129\222-\249\195\200\216@\005\130\141\241#\208\004\015\128\000\001\142\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\003\022\246\237\127\139\237\243\251\255\182\031}\183\255\207#a\000\022\n7\196\143@\016>\000\000\00681%.\195\232>\022\028\015\249`w\139~p\2426\016\001`\163|H\244\001\003\224\000\000c\130\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\197\189\187_\226\251|\254\255\237\135\223m\255\243\200\216@\005\130\141\241#\208\004\015\128\000\001\142\012IK\176\250\015\133\135\003\254X\029\226\223\156?\022\246\237\127\139\237\243\251\255\182\031}\183\255\207#a\000\022\n7\196\143@\016>\000\000\00681%.\195\232>\022\028\015\249`w\139~p\252[\219\181\254/\181\207\239\254\216}\246\223\255\127\022\246\237\127\139\237s\251\255\150\031x\183\255\207\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\216@\005\130\141\241#\208\004\015\128\000\001\142\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\128\000\000\000\000\000\000\000\000\000\000\000\000 \000\000#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\131\161\136\031\128\179\148\139O\140\134\193\000d\178\192\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\012\164\001\t\001L\018+\000\016\024\000\000P@\003\000\000\128\000\003\023\b\000\004\000\000\000\000\000\000@\000\000\000\016@\000\000\001\000\000\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003)\000B@S\004\138\192\004\006\000\000\020\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003)\000B@S\004\138\192\004\006\000\000\020\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\216@\005\130\141\241#\208\004\015\128\016\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0001%.\195\232>\022\028\015\249`w\139~p\2402\016\000 \0010H\180\000@h\000\000A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\131\018R\236>\131\225a\192\255\150\007x\183\231\015#a\000\022\n7\196\143@\016>\000\000\00681%.\195\232>\022\028\015\249`w\139~p\240\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\004\129\016#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000 \141\132\000X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200@\000\128\004\193\"\208\001\001\128\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\129!\b\016\002\003\004\142@\000\006\000\000\0060 \000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000\022\n7\196\143@\016>\000\000\0078\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\216@\133\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\018\016\001\000 0H\228\000\000`\000\000c\001\000\000\000\000\000\000\000\000\0000\000\005\000\000\000\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\001\016\000\000\000\000\000\000\000\004\000\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\017\000\000\000\000\000\000\000\000@\000\000\000 \000\004@\000\000\000\000\000\000\000\000\000\000\000\b\016\000\016\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\012\000\001@\000\000\000@\000\000\000\000\192#\128\000\000\000\000\000\000\012\000\001\016\000\000\000\000\000\000\192\004\020\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\148\187\015\160\248Xp?\237\129\223m\249\195\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\145\015\1280\016\016\015\129\128@\001`\128\224\000\004\000\000\000\000\000\000\000@\000\000\000\000\b\000\000\000\000\000\016\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\002\000\000\000\002\004\016\000\000@\000\000\000\000\000@\128\000\000\000\129\000\000\000\016\000\000\000\000\000\000\000\000\000\000 \001\000\002\000\000\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\192\000\000@\000\000\004\000\000\000\000\000\000\000\0000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000@\000\016\000\000@\128\000\000\000\129\000\000\000\016\000\000\000\000\bH\002 \002\b$\135\000\006@\025\128\000\128\016\004\001\000\000\002\012\016\000\000\001\000\000\000\000\000@\000\000\000\000@\000\016\000\000\000@\000\000\000\000@\128\000\000\000\129\000\000\000\016\000\000\000\000\bH\002 \002\b$\135\000\006@\025\128\000\128\016\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\004\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000\001\000\002\000\024\000\000\002\000\000\000\000\000H\000\000\000\000\128\006\000\000\000\128\000\000\000\000\018\000\000\000\000 \000\128\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000 \000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\001\000\002\000\000\000\001\000\000\012\000\002\000\000\012\\(\000\016\000\000\000\000\000\000\000\000\000\001\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\016\000\000\0000\000\012\004\0001p\128\000@\000\000\000\000\000\000\000D\000\000\000\000@\000\002\000\000\000\000\016\000\000\017\000\000\000\000\016\000\000\000\000\000\000\000\000\000\004@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\016\016\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\000\000\000\000\016\000\000\128\000\000\000\004\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\004\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\002\000\000\012\\ \000\016\000\000\000\000\000\133\128\162\000 \193Hp\000d\001\152\004\bA\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bX\n \002\b\020\135\000\006@\025\128@\132\016\012\000\002\000\000\012\\(\000\016\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\192\000 \000\000\197\194\000\001\000\000\000\000\000\bX\002 \002\b\020\135\000\006@\025\128@\132\018\022\002\136\000\131\005!\192\001\144\006`\016!\004\000\000\000\000\000\000\000\016\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003!\004\002\000\019\004\155@\004\006\000\000\004\016\000\200A\000\128\004\193\"\208\001\001\128\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\132\000\b\000L\018-\000\016\024\000\000\016@\132\128\"\000 \128H`\000d\001\152\000\b\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\018R\236>\131\225a\192\255\150\007x\183\231\015@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200@\000\128\004\193\"\208\001\001\160\000\001\020\012IK\176\250\015\133\135\003\254X\029\226\223\156>\000\002 >\000\192@@>\002\001\000\007\194\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\016\004\000\000\b0@\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\b\000\000@\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\016\004\000\000\b0@\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\b\000\000@\000\016\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\004\000\000\b0@\000\000\004\000\000\000\000\001\000\000 \000\001\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \b\128\b \146\028\000\017\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\b\000\000\000\b\016@\000\001\000\000\000\000\000\001\002\000\000\000\002\004\000\000\000@\000\000\000\000! \b\128\b \146\028\000\017\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\000\016\004\000\000\000@\000\000\000\000\000\000\000\001\000\000\001\000\001\000\016\000\000\000\000\000\000\000\000@\000\000\000\000@\004\000\000\000\000\000\000\000\000\016\000\000\000\000\016\000\000\000\000\000\000\000\000\002\018\000\136\000\130\001!\128\001\016\007`\000 \000\001\000@\000\000\131\004\000\000\000@\000\000\000\0001 \b\128\b0\018\028\000\017\000f\000\002\000\bH\002 \002\b\004\134\000\004@\025\128\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\004\000\000\000\000\016\000\000\000\000\000\000\000\000\192\001\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\001\000\000@\000\132\128\"\000 \128H`\000D\001\152\000\b\001! \b\128\b \018\016\000\017\000f\000\002\000@0\000\000\000\000\000\001\000\000\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000@\000\016\000! \b\128\b \018\024\000\017\000f\000\002\000HH\002 \002\b\004\132\000\004@\025\128\000\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\016\000\004\000\bH\002 \002\b\004\134\000\004@\025\128\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000}\246D \191\141@\0010p{\142,\n\r\t\248H\149\138\173\2433\208\020\015\224\000\007\142\0002\016\000 \0010H\180\000@h\000\000A\000@\000\b\000\000\000\000@\000\000\000\000\004\129\016#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\223dB\011\248\212\000\019\007\007\184\226\192\160\208\159\132\137X\170\2233=\001@\254\000\000x\224\001\002\000\001\000\002\004\016\000\000@\000\000\000\000\000@\128\000\000\000\129\004\000\000\016\000\000\000\000\000\016 \000\000\000 @\000\000\004\000\000\000\000\002\018\000\136\000\130\t!\192\001\016\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\192\004\000\000\000\000\000\000\000\000\000\000\000\000\0000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\192\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\004\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\132\129\"\000 \128H`\000D\001\152\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002 \002\b\004\134\000\004@\025\128\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000\001\000\002\000\024\000\000\002\000\000\000\000\000H\000\000\000\000\128\006\000\000\000\128\000\000\000\000\018\000\000\000\000 \000\128\000\000 \000\000\000\002\018\000\136\000\194\001!\192\001\016\007`\000`\000\001 \000\000\000\002\000\b\000\000\002\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\002\018\000\136\000\130\001!\192\001\016\006a\000!\000\001\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\bH\002 \002\b\004\135\000\004@\025\128\000\128\002\018\000\136\000\130\001!\128\001\016\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \b\128\b \018\028\000\017\000f\000\002\000\bH\002 \002\b\004\134\000\004@\025\128\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\128\"\192`\131\031H\000D\001\128\000\b\000! \b\128\b \002\016\000\016\000f\000\002\000\000\016\000\000\016\000\000\001\000\000\000\000\000\000\002\000\004\000\000\004\000\000\000@\000\000\000\000\000\000\000\001\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002 \002\b \134\000\004\000\025\132\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002 \002\b \134\000\004\000\025\132\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\128\004\001\000\000\000\016\000\000\000\000\000\000\000\000\192\001\000\000\000\000\004\000\000\000\000\000\000\000\0000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\001\000\001@\000\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002 \002\b \134\000\004\000\025\132\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\016\004\000\000\b0@\000\000\004\000\000\000\000\003\018\000\136\000\131\000!\192\001\000\006`\000 \004\132\128\"\000 \128\b@\000@\001\152\000\b\001\000\192\000\000\000\000\000\004\000\000\000\000\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\001\000@\000\000\131\004\000\000\000@\000\000\000\0001 \b\128\b0\002\028\000\016\000f\000\002\000HH\002 \002\b\000\132\000\004\000\025\128\000\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\016\000\004\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\002\018\000\136\000\130\000!\128\001\000\006a\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\016\000\000 \193\000\000\000\016\000\000\000\000\012H\002 \002\012\000\135\000\004\000\025\128\000\128\002\018\000\136\000\130\000!\128\001\000\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\001\000\004\002\012\016@\000\001\000\000\000\000\000\001\000@\000\000\131\004\016\000\000@\000\000\000\000\000@\016\000\000 \193\000\000\000\016\000\000\000\000\012H\002 \002\012\000\135\000\004\000\025\128\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000\001\000\002\000\024\000\000\002\000\000\000\000\000H\000\000\000\000\128\006\000\000\000\128\000\000\000\000\018\000\000\000\000 \000\128\000\000 \000\000\000\002\018\000\136\000\194\000!\192\001\000\006`\000`\000\b\128\000\001\000\001\000\024\000\000\000\000\000\000\000\002\000\000\000@\000@\006\000\000\000\000\000\000\000\000\128\000\000\000\000\016\001\128\000\000\000\000\000\000\000 \000\000\000\000\004\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\002\000\000\000\000\000\000\000\000 \000\b \001\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\004\000\000\000 \005\016 \000\000\000\000\000\000\000\132\000\000\000\000\n\bP\016\000\000\b\004\000\000!\000\000\000\000\002\130\016\004\000\000\002\001\000\000\0000\000\012\004\0001p\128\000@\000\000\000\000\000\000\000 \000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\000\000\000\000\002\002\016\004\000\000\002\001\000\000\000\128\000\000\000\016\016\001\000\000\000\000\000\000\000\000 \000\000\000\004\004\000\000\000\000\000\000\000\000\000\000\000\000\000\001\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\0000\000\012\004\0001p\128\000@\000\000\000\000\002\016\000\000\000\000 !\192@\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\b\000\000@\004\000\000\000\000\000\000\000\000\128\000\002\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\128\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\192\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\004\000\000\000\012\000\003\001\000\012\\ \000\016\000\000\000\000\000\132\000\000\000\000\b\bp0\000\000H\004\000\000!\000\000\000\000\002\002\024\004\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\016\000\000\000\000 !\192\192\000\001 \016\000\000\001\000\000\000\b\001D\024\000\000\000\000\000\000\000\000@\000\000\002\000Q\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\016\000\000\000\000\000\000 \000@\000\000\000\000\000\004\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\001\000\000\000\001\000\000\000\b\001D\b\000\000\000\000\000\000\000\000\192\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\016\000\000\004\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000@\000\000\000@\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\128\000\000\000\004\000\000\000\000\000@\000\000\000\000 \000\000\000\001\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \n\128\b\"\018\028\004\017\000v\001\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000@\000\000\000@\000\000\002\000Q\002\000\000\000\000\000\000\000\bH\002\160\002\b\132\135\001\004@\029\128@\128\018\016\000\000\000\000 !\192@\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\192\0000\016\000\197\198\000\001\000\000\000\000\000\0000\000\012\004\0001p\128\000@\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\000\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000!\000\000\000\000\002\002\028\012\000\000\002\001\000\000\b@\000\000\000\000\128\134\001\000\000\000\128@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\016\000\000\000\000 !\128@\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b@\000\000\000\000\128\132\001\000\000\000\128@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\000 \128Hp\000D\001\152\000\b\001! \b\128\b \018\016\000\017\000f\000\002\000@\128\000\000\000\000\016\001\128\000\000\000\000\000\000\000 \000\000\000\000\004\000 \000\000\000\000\000\000\000\000\000\000\000\000\001\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\004\000\000\000 \005\016 \000\000\000\000\000\000\000\132\128\"\000 \128Hp\000D\001\152\000\b\001! \b\128\b \018\016\000\017\000f\000\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\001\000\024\000\000\000\000\000\000\000\002\000\000\000\000\000@\002\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\128\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\192\0000\018\000\213\194\000\001\000\000\000\000\000\bX\n\160\002\012\016\135\000\004@\029\128\001\128\016\012\000\002\000\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\192\0000\018\000\213\194\000\001\000\000\000\000\000\0000\000\012\004\0001p\128\000@\000\000\000\005\000\000\000\b\000\000\000\000@\000\000\000\000\004\001\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\192\0000\018\000\213\194\000\001\000\000\000\000\000\0000\000\b\000\0001p\128\000@\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\003\000\000\192H\003W\b\000\004\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\016\000\000\000\016\000\000\000\000\016\000\000\000\000\000\000\000\000\002\022\002\168\000\131\004!\192\001\016\007`\000 \004\133\128\170\000 \193\bp\000D\001\216\000\b\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002\160\002\b\000\135\000\004\000\029\128\000\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \b\128\b \002\024\000\016\000f\000\002\000HH\002 \002\b\000\132\000\004\000\025\128\000\128\016 \000\000\000\000\004\000`\000\000\000\000\000\000\000\b\000\000\000\000\001\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000@\002\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\003\000\000\192H\003W\b\000\004\000\000\000\000\000! \b\128\b \002\024\000\016\000f\000\002\000HH\002 \002\b\000\132\000\004\000\025\128\000\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002 \002\b\000\132\000\004\000\025\128\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \b\128\b \002\024\000\016\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\018\000\136\000\130\000!\000\001\000\006`\000 \004\002\000\000\130\000\019\000\016\000\000\000\000\000\000\000\000\128\000 \128\004\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\002\018\000\136\000\130\001!\128\001\016\007`\016 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \b\128\b \018\024\000\017\000f\001\002\000HH\002 \002\b\004\132\000\004@\025\128\000\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \b\128\b \002\016\000\016\000f\000\002\000@ \000\b \0010\001\000\000\000\000\000\000\000\000\b\000\002\b\000L\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\0002\000\014\004\0001p\160\000@ \b\000\004\000\012\000\011\001\000\012\\ \000\016\000\000\000\001@\000\000\000\000\001\001\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\133\160\"\000 \130Hh\000D\003\152\004\b\001! \b\128\012 \018\028\000\017\000f\001\006\016HH\002 \002\b\004\135\000\004@\025\128@\132\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\000 \128H`\000D\001\152\004\bA\000H\000\000\000\000\128\002\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\000 \128\b`\000@\001\152\004\b\001! \b\128\b \002\016\000\016\000f\000\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \b\128\b \018\028\000\017\000v\001\002\000@\018\000\002\000\000 \000\160\000\000 \b\000\004\000\004\128\000\000\000\b\000(\000\000\b\002\000\001\000\000\000\000\000\001\001\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \b\128\012 \018\028\000\017\000f\001\006\016HH\002 \002\b\004\135\000\004@\025\128@\132\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\001\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\016\000\000\000\000\000\000\000\002 \000\000@\000@\006\000\000\000\000\000\000\000\000\128\000\000\000\000\016\001\128\000\000\000\000\000\000\000 \000\000\000\000\004\000 \000\000\000\000\000\000\000\000\000\000\000\000\001\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\0002\144\004$\0010H\172\000@d\000\001A\000\004\000\000\000 \r\016 \000\000@\000\000\000\000\132\000\000\000\000\n\bP0\000\000\b\004\000\000!\000\000\000\000\002\130\016\012\000\000\002\001\000\000\b@\000\000\000\000\128\132\003\000\000\000\128@\000\000 \000\000\000\004\004\000@\000\000\000\000\000\000\128\000\000\000\000\001\001\000\016\000\000\000\000\000\000\000\000\000\000\000\000@@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\002@\000#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\141\132\000X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\000\000\000\000\002\002\024\012\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\004\004\000\000\000\000\000\000\000\000\000\000\000\000\000\001\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\0000\000\012\004\0001p\128\000@\000\000\000\000\002\016\000\000\000\000 !\192\192\000\000 \016\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000$\000\0026\016\001`\163|H\244\001\003\224\000\000c\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\b\216@\005\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\128\000\004\000@\000\000\000\000\000\000\128\000\000\000 \000\001\000\016\000\000\000\000\000\000\000\000\000\000\b\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\003)\000B@\019\004\138\192\004\006@\000\020\016\000\224\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\b\216@\005\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\000\000\000\000\b\b`0\000\000\b\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\002\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\128\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\192\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\003)\000B@\019\004\138\192\004\006@\000\020\016\000\224\0000\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\b\216@\005\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000\022\n7\196\159@\016>\000\000\0068\b\216@\005\130\141\241#\208\004\015\128\000\001\142\b@\000\000\000\000\128\134\003\000\000\000\128@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\b\003D\024\000\000\016\000\000\000 \000@\000\000\002\000\209\006\000\000\004\000\000\000\000\000\016\000\000\000\1284@\128\000\001\000\000\000\000\000\004\000\000\000 \r\016 \000\000@\000\000\000\000\003!\004\003 \019\004\155@\004\006\000\000\004\016\031}\145\b/\227P\000L\028\030\227\139\002\131@2\016@ \0010I\180\000@`\000\000A\000\012\132\016\b\000L\018-\000\016\024\000\000\016@\003!\000\002\000\019\004\139@\004\006\000\000\004\016\000\000\000\000\000\000\000\b\000\b\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000@\000\000\000\000\000\000\128\001\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\004\000\000\000\004\000\000\000 \r\016 \000\000@\000\000\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000@\000\000\016\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003)\000B@\019\004\154\192\004\006\000\000\004\016\000\202@\016\144\004\193\"\176\001\001\128\000\001\004\0002\144\004$\0050H\172\000@`\000\000A\000\004\000\000\000 \r\016 \000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\001\000@\000\000\002\000\209\002\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\022\164\169A\138-3\251\193\016\030`\016x\212\133\169*Pb\139L\254\240D\007\152\004\0305\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002\160\002\b\132\135\003\004@\025\128A\128P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \n\128\b\"\018\028\012\017\000f\001\006\001@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128*\000 \136Hp0D\001\152\004\024\005\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\004\000\000\000\004\000\000\000 \r\016 \000\000@\000\000\000\000\132\128*\000 \136Hp0D\001\152\004\024\005\000\200A\000\128\004\193\"\208\001\001\128\000\001\004\0002\016\000 \0010H\180\000@`\000\000A\000\000\000\000\000\000\000\000\128\000\128\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\002\000\000\000\000\004\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\192H\003W\b\000\004\000\000\000\000\000 \000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\000\000\000\000\b\bp0\000\000\b\004\000\004\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\016\000\000\000\000 !\128\192\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\002\000\209\002\000\000\004\000\000\000\000\b@\000\000\000\000\128\135\003\000\000\000\128@\000B\016\000\000\000\000 !\128\192\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\192\0000\016\000\197\198\000\001\000\000\000\000\000\0000\000\012\004\0001p\128\000@\000\000\000\000\002\016\000\000\000\000 !\128\192\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\000\000\000\000\b\b`0\000\000\b\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\016\000\000\000\000 !\000\192\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \b\128\b \018\028\000\017\000f\000\002\000@0\000\012\004\1285p\128\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\001\000\000\000\b\003D\b\000\000\016\000\000\000\000! \b\128\b \018\028\000\017\000f\000\002\000@2\144\004$\0010H\172\000@d\000\001A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\000 \128H`\000D\001\152\000\b\001! \b\128\b \018\016\000\017\000f\000\002\000@\128\000\000\000\000\016\001\128\000\000\000\000\000\000\000 \000\000\000\000\004\000 \000\000\000\000\000\000\000\000\000\000\000\000\001\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\0002\144\004$\0010H\172\000@d\000\001A\002\018\000\136\000\130\001!\128\001\016\006`\000 \004\132\128\"\000 \128H@\000D\001\152\000\b\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\000 \128H@\000@\001\152\000\b\000\000\200A\000\192\004\193&\208\001\001\128\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\000 \128H@\000D\001\152\000\b\001! \b\128\b \018\024\000\017\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\018\000\136\000\130\001!\000\001\016\006`\000 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\000 \128H`\000@\001\152\000\b\000! \b\128\b \018\016\000\016\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002 \002\b\004\132\000\006@\025\128\000\128\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \b\128\b \018\024\000\016\000f\000\002\000\bH\002 \002\b\004\132\000\004\000\025\128\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\128*\000 \194Hp\000D\001\216\000\136\0010\000\002\000\000\016\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\016\000\000\000\000\0010D\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\012\004\0001p\128\000@\000\000\000\000\000\000\000 \000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\000\000\000\000\002\002\016\012\000\000\002\001\000\000\b\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\016 \000\016\000 A\000\000\004\000\000\000\000\000\004\b\000\000\000\b\016@\000\001\000\000\000\000\000\001\002\000\000\000\002\004\000\000\000@\000\000\000\000\000\000\002\000\000\000\128\004\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\004\001\000\000\002\012\016\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\002\000\000\016\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000 \000\000\000\000\000\000\000\000\000\002@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \200@\000\128\004\193\"\208\001\001\160\000\001\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\018R\236>\131\225a\192\255\150\007x\183\231\015\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\001 \000 \000\002\000\b\000\000\002\000\000\000@\000H\000\000\000\000\128\002\000\000\000\128\000\000\016\000\018\000\000\000\000 \000\128\000\000 \000\000\000\002\018\000\136\000\194\001!\192\001\016\007`\000a\000\001 \000\000\000\002\000\b\000\000\002\000\000\000\000! \b\128\b \018\028\000\017\000f\000\002\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\018\000\136\000\130\001!\128\001\016\006`\000!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\018\000\136\000\194\001!\192\001\016\007`\000a\000\001 \000\000\000\002\000\b\000\000\002\000\000\000\000! \b\128\b \018\028\000\017\000f\000\002\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\004\000\000\000\000\000\000\000\000\000\132\128\"\b \128H`\000D\001\216\004\b\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002 \002\b\004\134\000\004@\025\128@\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000H\000\b\000\000\128\002\000\000\000\128\000\000\016\000\018\000\000\000\000 \000\128\000\000 \000\000\004\002\018\000\136\000\130\001!\128\001\016\006`\000!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000@\000\002\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\128\000\000\000\000\000\192\000 \000\000\197\198\000\001 \000 \000\000\0000\000\b\000\0001p\128\000H\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\004\000\000\000@\000\000\001 \000\000\000\000\0000\000\b\000\0001p\128\000H\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\016\000\000\004\000\000\000\000\004\000\000\000\016\000\000\000\000\000\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\003\001\000\012\\ \000\016\000\000\000\000\000\000\000\b\000\000\000\000\016\000\000\000\000\001\000\000\000\000\002\000\000\000\000\004\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\003\001\000\012\\ \000\016\000\000\000\000\000\000\000\b\000\000\000\000\016\000\000\000\000\001\000\000\000\000\000\000\000@@\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \b\128\b \018\028\000\017\000f\001\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003 \000\224@\003\023\n\000\004\002\000\128\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002 \002\b\000\134\000\004\000\025\128@\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000H\000\b\000\000\128\002\000\000\000\128\000\000\016\000\018\000\000\000\000 \000\128\000\000 \000\000\004\002\018\000\136\000\130\000!\128\001\000\006`\000!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000! \b\130\b \002\024\000\016\000v\001\018\000@2\000\014\004\0001p\160\000@ \b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\000 \128\b`\000@\001\152\004\b\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\004\128\000\128\000\b\000 \000\000\b\000\000\001\000\001 \000\000\000\002\000\b\000\000\002\000\000\000@! \b\128\b \002\024\000\016\000f\000\002\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\128\000\004\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\000 \128Hp\000D\001\152\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\0026\016\001`\163|H\244\001\003\224\000\000c\128\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128 \000 \128\b@\000@\001\144\000\b\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000\022\n7\196\143@\016>\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003!\000\002\000\019\004\139@\004\006\128\000\004\016\000\000\000\000\000\000\000\004\000\000\000\004\000H\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000'\225 \022*\183\204\207@T?\144\000\0148\000@\000\000\000\000@\000\000\000\000\000\000\000\000\000Z\018\000\002\b4\132\004\004@9\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128 \000 \128H@\000D\001\144@\b\000\000@\000\000\000\000\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000H\002\000\002\b\004\132\000\004\000\024\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000 \000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\248H\005\138\173\2433\208\021\015\228\000\003\142\002~\018\001b\171|\204\244\005C\249\000\000\227\128\018\000\128\000\130\001!\000\001\016\006@\000 \000\004\128 \000 \128H@\000D\001\144\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\018\000\128\000\130\001!\128\001\016\006@\000 \000\004\128 \000 \128H@\000D\001\144\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128 \000 \128H`\000D\001\144\000\b\000\001 \b\000\b \018\016\000\017\000d\000\002\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")
+ (124, "'\225 \197\138\173\2433\208\020\015\228\000\003\142\0026\016\004\\(\223\018}\000@\248\000\000\024\224}\246D\b/\227P\000L\028\030\227\139\002\131@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\175\235f\245\155\175\2437\252\021\031\226\017\007\158\007\223d@\130\2545\000\004\193\193\2388\176(4\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000E\130\141\241'\208\004\015\128\000\001\142\007\223d@\130\2545\000\004\193\193\2388\176(4'\225\"\213\138\173\2433\208\020\015\224\000\007\142\000\000\000\000\004\000\012\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\192\004\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\128\000\128\007\224,$\000\003\226 \016@\016(\176\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000(\000\000\000\000\000\000\000\000\000\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\128\000\b\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\018\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\128\000\b\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\128\000\b\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\007\001\002\012\\ \000\016\000\000\000\000\000\001\000@@@ \193\004\000\000\016\000\000\000\000\000\016\004\004\000\002\012\016@\000\001\000\000\000\000\000\001\000@@\000 \193\000\000\000\016\000\000\000\000\012H\002\168\000\131\t!\192\001\016\007a\002 \004\132\128 \128\b \002\020\000\016\000b\000\002\000\bH\002\b\000\130\000!\000\001\000\006 \000 \000\003\000\000 \193\004\192\004\000\000\000\000\000\000\000\0000\000\002\b\016L\000@\000\000\000\000\000\000\000\003\000\000 \129\004\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000 \128\004\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000 \128\004\000\000\000\000\000\000\000\000\000\000 \000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\002\b\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\132\128\"\130\b \002\024\000\016\000v\001\018\000@2\000\007\129\000\012\\(\000\016\b\002\000\001\000\132\128\"\128\012 \146\028\000\017\000f\017\006\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003 \000p\016\000\197\194\128\001\000\128 \000\016\0000\000\135\001\002\012\\ \000\016\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012X\011\184\000\131%!\192\193\018\007`\022a\022\003\000\000`\000\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000`\000\000\197\194\000\001 \000 \000\000\000\016\001\000\000\000\004\000\000\000\018\000\000\000@\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\133\000\145\160\000\018B\028\012\001 \018\017 \001\007\223d@\130\2545\000\004\193\193\2388\176(4'\225\"\213\138\173\2433\208\020\015\224\000\007\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\002\012\016L\000@\000\000\000\000\000\000\000\003\000\000 \129\004\192\004\000\000\000\000\000\000\000\0000\000\002\b\016L\000\000\000\000\000\000\000\000\000\003\000\000 \128\004\192\000\000\000\000\000\000\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\132\128\"\130\b \018\024\000\017\000v\001\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\024\000\017\000f\001\002\000G\223d@\130\2545\000\004\193\193\2388\176(4'\225\"\213\138\173\2433\208\020\015\224\000\007\142\0026\016\004\\(\223\018}\000@\248\000\000\024\224#a\000E\130\141\241'\208\004\015\128\000\001\142\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\018\016\004@\b\012\0189\000\000\024\000\000\024\192\001\000\000\000@\000@\004\000\000\000\000\000\000\000\000\016\000\000\000\000\004\000@\000\000\000\000\000\000\000\001\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\254\183\127\217\190\255\127\255\193\211\254b\0169\228\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n6\024\132~*\223R=>b\249\004\001\154\235\129!\bD\000\128\193#\144\000\001\128\000\001\140\0026\016\004X(\223\018=\000@\248\000\000\028\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\000\000\128@\002\130\020\012\000\000\002\001\000\000\b@\000\b\000\000(!@\192\000\000 \016\000\000\132\000\000\128\000\002\130\016\012\000\000\002\001\000\000\0002\016\004\b\000L\018-\000\016\026\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b2\024\132~\002\206R->2\027\004\001\146\203\128\000\b\000\000\000\000\000\016\000\001\000\000\000\000\b0\000\000\004\000\000\000@\000\000\000\000\000\000\000\003\000\000\000\000\000\000\004\000\000\000\000\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000@@\000 \193\000\000\000\016\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\016 \004\000\000\b\016@\000\001\000\000\000\000\000\001\002\000@\000\000\129\000\000\000\016\000\000\000\000\n~\018\012X\170\2233}\001@\254 \0008\224\167\225 \197\138\173\2433\208\020\015\226\000\003\142\n~\018,X\170\2233=\001@\254`\0008\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016 \004\004\000\b\016@\000\001\000\000\000\000\128\001\002\000@@\000\129\004\000\000\016\000\000\000\000\000\016 \004\000\000\b\016@\000\001\000\000\000\000\000\001\002\000@\000\000\129\000\000\000\016\000\000\000\000\000P \004\000\000\b\016\000\000\001\000\000\000\000\000#a\000E\130\141\241'\208\004\015\128\000\001\142\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000E\194\141\241'\208\004\015\128\000\001\142\0026\016\004X(\223\018}\000@\248\000\000\024\224#a\000E\130\141\241#\208\004\015\128\000\001\142\012[\219\189\127\139\237\243\251\255\182\031}\183\255\207#a\000E\130\141\241#\208\004\015\128\000\001\142\0002\016\004\b\000L\018-\000\016\024\000\000\016@\003!\000@\128\004\193\"\208\001\001\160\000\001D\0002\016$\b\000L\018-\000\016\026\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\017\000\000\000\000\000\000\000\000\016\000\004\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\004\0000\000'\001\000\012\\ \000\016\000\000\000\001@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000@\003\000\000p\016\000\197\194\000\001\000\000\000\000\020\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\016\000\000\b\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\b\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\004\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\128;\128\b2\018\028\012\017 v\001b\017`0\000\007\001\000\012\\ \000\016\000\000\000\000\000\196\128\187\128\b2\018\028\012\017 v\001b\017`0\000\006\000\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197\128\187\128\b2R\028\012\017 v\001b\017`\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000`\000\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197\128\187\128\b2R\028\012\017 v\001b\017`0\000\006\000\000\012\\ \000\016\000\000\000\000\000\197\128\187\128\b2R\028\012\017 v\001b\017`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\004\000\000\004\000\000 \000\000\000\016\0000\000\007\001\000\012\\ \000\016\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\002\000\000\000\000\004\000\000 \000\000\000\016 0\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000@\000\002\000\000\000\001\018\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\004\000\000 \000\000\000\017 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\004\000\000 \000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\128;\128\b2\018\028\012\017 v\001b\017@\000\000 \000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\004\000\000\000 \000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\002\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\002\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\017\000\000\000\000\004\000\000\000\016\000\000\000\b\000\001\016\000\000\000\000\000\000\000\001\000\000\000\000\003!\000@\128\004\193\"\208\001\001\160\000\001\004\0002\016\004\012\000L\018i\000\016\024\000\000\016@\003!\000@\128\004\193&\144\001\001\128\000\001\004\0002\016\004\b\000L\018)\000\016\024\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t2\145\181\t\001L\018k\000\016\025B\006\213P\000\001\000\000\128\004\000\000\016\000\001\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\147)\027P\144\020\193&\240\001\001\180\016mU\000\016\000\000\000\000\b\002(\000\000\000\000\000\000\000\131!\b@\128\004\193\"\208\001\001\160\000\t\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0002\016\004\012\000L\018m\000\016\026\000\000\016@\003!\000@\128\004\193&\208\001\001\160\000\001\004\0002\016\004\b\000L\018-\000\016\026\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\000\027\000\000\016\000\004\000\000\000\020\000LQ\0002\016\004\b\000L\018-\000\016\026\000\000\016@\144\000\027\000\000\016\000\004\000\000\000\020\000LQ\b2\016\004\b\000L\018-\000\016\026\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\001\176\000\001\000\000@\000\000\001@\004\197\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t2\017\180\b\001L\018m\000\016\027@\004\213P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\147!\027@\128\020\193&\208\001\001\180\000MU\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\b\000\000\000\000\004\000\000\000\000\000H\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b2\016\004\b\000L\018-\000\016\026\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\001\176\000\001\000\000@\000\000\001@\004\197\016\131!\000@\128\004\193\"\208\001\001\160\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\000\027\000\000\016\000\004\000\000\000\020\000LQ\b\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003!\002@\128\004\193\"\208\001\001\160\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\001 \000\000\000\000@\000\000\000\000\004\133\016\131!\002@\128\004\193\"\208\001\001\160\000\001D\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\017\000\000\000\000\004\000\000\000\000\000H\017\b\000\001\016\000\000\000\000\000\000\000\000\000\000\000\000\131\000\001\000\000\000@\000\000\000\000\000\000\000\000\b\000\001\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0002\144\005\t\000L\018k\000\016\025\000\004\209P\000\000\000\000\000\000\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\016\000\004\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\b\000\000\000\000\004\000\000\000\016\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\016\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\003!\004@\200$\193&\208\001\001\160\000\001\004\000\016 \004\004\000\b\016@\000\001\000\000\000\000\128\001\002\000@@\000\129\004\000\000\016\000\000\000\000\000\016 \004\000\000\b\016@\000\001\000\000\000\000\000\001\002\000@\000\000\129\000\000\000\016\000\000\000\000\000\000\000\000\000\000\b\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\0000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\001\000@@\000 \193\000\000\000\016\000\000\000\000\000\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\000\000\000\000\000\000\128\004\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\128\000\000\000\000\000\000\000\000\000\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012H\002\168\000\131\001!\192\001\016\007`\002 \004\000\128\000\000\000 \000\000\000\000\000\000\000\000\000\0000\000\002\b\000L\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001\000\000\003\000\000x\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\012H\002\168\000\131\001!\192\001\016\007`\002 \020\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\012H\002\168\000\131\001!\192\001\016\007`\018 \020\196\128*\128\b0\018\028\000\017\000v\001\"\000@0\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000\000\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\196\128*\128\b0\018\028\000\017\000v\001\"\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\001\001\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012H\002\168\000\131\t!\192\001\016\007a\002 \004\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\128*\128\b0\146\028\000\017\000v\016\"\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\128*\128\b0\018\028\000\017\000v\000\"\000@\b\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\196\128*\128\b0\018\028\000\017\000v\000\"\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\016\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\196\128*\128\b0\146\028\000\017\000v\016\"\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\000\128\000\001\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\b\000\000\016\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\128\000\000\000\000\000\000\000\000\000\016 \004\000\000\b\016\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012H\002\168\000\131\t!\192\001\144\007`\002`\004\005\002\b@\000\000\129\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\b\000\000\000\128\004\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\192\000\b\000\000\016\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012H\002\168\000\131\t!\192\001\144\007a\002`\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000@\000\128\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\0026\016$X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000@\000\000\000@\000\000\000\000\b\000\001\000\000\000\000\000\000\000\004\001\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\018\016\004@\b\012\0189\000\000\024\000\000\024\192\192\000\017\000\000\000\000\000\000\003\000\016P$\000\0026\016\004\\(\223\018}\000@\248 \000\024\224#a\000E\130\141\241'\208\004\015\130\000\001\142\0026\016\004X(\223\018=\000@\248 \000\024\224\001!\000D@\128\193'\144\000\001\128\000\001\140\000\018\016\004@\b\012\018y\000\000\024\000\000\024\192\001!\000D\000\128\193#\144\000\001\128\000\001\140\000\018\016\004@\b\012\0189\000\000\024\000\000\024\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197\189\187\215\248\190\215?\191\251a\247\219\127\253\240\016\000\000\000\000\012\0028\000\000\000\000\000\000\000\163a\136G\226\173\245#\211\230/\144@\025\174\176\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\163a\bE\130\141\241#\208\004\015\128\000\001\142\n6\016\132X(\223\018=\000@\248\000\000\024\224\129\002\000@@\000\129\004\000\000\016\000\000\000\000\000\016 \004\000\000\b\016@\000\001\000\000\000\000\000\001\002\000@\000\000\129\000\000\000\016\000\000\000\000\000\000\000\000\000\000\b\000@\000\000\000\000\000@\000\129\000@@\000 \193\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\b\000\000\016\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\163a\bE\130\141\241#\208\004\015\128\000\001\142\n6\016\132X(\223\018=\000@\248\000\000\024\224\131!\b@\128\004\193\"\208\001\001\128\000\001\004\000\000\000\000\000\000\000\000@\000\000\001\000\004\193\016\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\0026\016\004\\(\223\018}\000@\248\000\000\024\224#a\000E\130\141\241'\208\004\015\128\000\001\142\0026\016\004X(\223\018=\000@\248\000\000\024\224\003!\000@\192\004\193&\208\001\001\160\000\001\020\0002\016\004\b\000L\018m\000\016\026\000\000\017@\003!\000@\128\004\193\"\208\001\001\160\000\001\020\0002\016\004\b\000L\018-\000\016\026\000\000\016@\016\000\000\000\000\016\000\004\000\000\000\000\000H\017\0026\016\004X(\223\018=\000@\248\000\000\024\224\003)\000P\208\004\193&\176\001\001\128\000\001\004\0002\144\005\t\000L\018k\000\016\024\000\000\016@\003)\000P\144\004\193\"\176\001\001\128\000\001\004\000 \000\000\000\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0002\016\004\b\000L\018-\000\016\026\000\000\016@\000\000\b\000\000\000\000\004\000\000\000\016\000L\017\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\b\000\000\000\000\004\000\000\000\016\000\000\000\000\000\000\128\000\000\000\000\000\000\000\001\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\131\161\136G\224,\229\"\211\227!\176@\025,\176\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000@\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\0002\144\005\t\001L\018+\000\016\024\000\000P@#a\000E\130\141\241#\208\004\015\128\000\001\142\0002\016\004\012\000L\018m\000\016\026\000\000\016@\003!\000@\128\004\193&\208\001\001\160\000\001\004\0002\016\004\b\000L\018-\000\016\026\000\000\016@\000\000\000\000\000\000\000\004\000\000\000\016\000H\017\0026\016\004X(\223\018=\000@\248\000\000\024\224\001!\000D@\128\193'\144\000\001\128\000\001\140\000\018\016\004@\b\012\018y\000\000\024\000\000\024\192\001!\000D\000\128\193#\144\000\001\128\000\001\140\012IK\184>\131\225a\192\255\182\007}\183\231\015\001!\000D\000\128\193#\144\000\001\128\000\001\140\012[\219\189\127\139\237s\251\255\182\031}\183\255\223\000\000\000\000\000\000\128\002\128\000\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224#a\000E\130\141\241#\208\004\015\128\000\001\142\012[\219\189\127\139\237s\251\255\182\031}\183\255\207\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001!\000D\000\128\193#\144\000\001\128\000\001\140\012[\219\189\127\139\237s\251\255\182\031}\183\255\223\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\192\002\128\000\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\128\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012IK\184>\131\225a\192\255\150\007x\183\231\015#a\000E\130\141\241#\208\004\015\128\000\001\142\012[\219\189\127\139\237s\251\255\182\031}\183\255\207\196\148\187\131\232>\022\028\015\251`w\219~p\240\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\004#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\240\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197\189\187\215\248\190\215?\191\251a\247\219\127\252\252IK\184>\131\225a\192\255\182\007}\183\231\015#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\231\245\187\199\234\191\247?\223\253o\247\139\127\254\247\223d@\130\2545\000\004\193\193\2388\176(4#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2402\016\004\b\000L\018m\000\016\024\000\000\016@\003!\000@\128\004\193\"\208\001\001\128\000\001\004\0002\144\005\t\000L\018k\000\016\025\000\006\209P\131\161\136G\224,\229\"\211\227!\176@\025,\176\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\0002\144\005\t\000L\018+\000\016\025\000\002P@\003!\000@\128\004\193\"\144\001\001\128\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\131\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\025\000\000\000\000\004\000\000\000\016\000\000\000\b0\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\001\144\000\000\000\000@\000\000\001\000\002\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\b\000\001\144\000\000\000\000@\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0002\144\005\t\000L\018+\000\016\025\000\002P@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\b\000\000\000\000\000\016\000\001\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\128\000\000\000\000@\000\000\000\000\004\193\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\131\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\b\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b8\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\016\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\004\193\016\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000H\017\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b2\016\004\b\000L\018-\000\016\026\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\004\129\016\131!\000@\128\004\193\"\208\001\001\160\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000H\017\b2\016\004\b\000L\018-\000\016\026\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\004\129\016\128\000\000\000\000\000\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\004\129\016\003!\000@\128\004\193\"\208\001\001\160\000\001\004\000\000\000\000\000\000\000\000@\000\000\001\000\004\129\016\132\128\"\128\b \018\024\000\025\000f\000\002\000HH\002(\000\130!!\128\193\144\006`\016 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012IK\184>\131\225a\192\255\150\007x\183\231\015#a\000E\130\141\241#\208\004\015\128\000\001\142\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\b\000\b\016>\000\192@@>\002\001\000\005\130\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000P\000\000\000\000\000\000\000\000\b\000(\000\000\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\b\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\155\003\224\012\004\004\003\224 \016\000X`:6\016\180X(\223\018=\000@\248\000\000\028\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\128\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001!\000D\000\128\193#\144\000\001\128\000\001\140\012[\219\189\127\139\237s\251\255\182\031}\183\255\223\000\000\000\000\000\000\128\002\128\000\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\128\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197\189\187\215\248\190\223?\191\251a\247\219\127\252\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197\189\187\215\248\190\223?\191\251a\247\219\127\252\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\012[\219\189\127\139\237\243\251\255\182\031}\183\255\207#a\000E\130\141\241#\208\004\015\128\000\001\142\012IK\184>\131\225a\192\255\150\007x\183\231\015\128\000\145\003\224\012\004\004\003\224 \016\000X 0\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\192\002\128\000\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\128\000\b\000\000\000\000\000\000\000\000\000\000\000\000\012[\219\189\127\139\237\243\251\255\182\031}\183\255\207#a\000E\130\141\241#\208\004\015\128\000\001\142\012IK\184>\131\225a\192\255\150\007x\183\231\015#a\000E\130\141\241#\208\004\015\128\000\001\142\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\197\189\187\215\248\190\223?\191\251a\247\219\127\252\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\128\000\129\003\224\012\004\004\003\224 \016\000X <[\219\189\127\139\237\243\251\255\182\031}\183\255\207#a\000E\130\141\241#\208\004\015\128\000\001\142\012IK\184>\131\225a\192\255\150\007x\183\231\015\000\000\000\000\000\000\000\000\000\000\000\000P\000\000\000\000\000\000\000\000\b\000(\000\000\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\b\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\197\189\187\215\248\190\223?\191\251a\247\219\127\252\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\2426\016\004X(\223\018=\000@\248\000\000\024\224\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\012[\219\189\127\139\237\243\251\255\182\031}\183\255\207#a\000E\130\141\241#\208\004\015\128\000\001\142\012IK\184>\131\225a\192\255\150\007x\183\231\015#a\000E\130\141\241#\208\004\015\128\000\001\142\b\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\197\189\187\215\248\190\223?\191\251a\247\219\127\252\2426\016\004X(\223\018=\000@\248\000\000\024\224\196\148\187\131\232>\022\028\015\249`w\139~p\252[\219\189\127\139\237\243\251\255\182\031}\183\255\207#a\000E\130\141\241#\208\004\015\128\000\001\142\012IK\184>\131\225a\192\255\150\007x\183\231\015\197\189\187\215\248\190\215?\191\251a\247\219\127\253\252[\219\189\127\139\237s\251\255\150\031x\183\255\207\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\131\161\136G\224,\229\"\211\227!\176@\025,\176\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\0002\144\005\t\001L\018+\000\016\024\000\000P@\003\000\000`\000\000\197\194\000\001\000\000\000\000\000\000\016\000\000\000\001\004\000\000\000\016\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003)\000P\144\020\193\"\176\001\001\128\000\005\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003)\000P\144\020\193\"\176\001\001\128\000\005\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\001\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012IK\184>\131\225a\192\255\150\007x\183\231\015\003!\000@\128\004\193\"\208\001\001\160\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\012IK\184>\131\225a\192\255\150\007x\183\231\015#a\000E\130\141\241#\208\004\015\128\000\001\142\012IK\184>\131\225a\192\255\150\007x\183\231\015\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\004\129\016#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\1306\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0002\016\004\b\000L\018-\000\016\024\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\129!\bD\000\128\193#\144\000\001\128\000\001\140\b\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0026\016$X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001!\000D\000\128\193#\144\000\001\128\000\001\140\004\000\000\000\000\000\000\000\000\0000\000\005\000\000\000\001\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\017\000\000\000\000\000\000\000\000\016\000$\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\017\000\000\000\000\000\000\000\000\016\000\000\000\b\000\001\016\000\000\000\000\000\000\000\000\000\000\000\000\129\000\001\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\003\000\000P\000\000\000\016\000\000\000\000\012\0028\000\000\000\000\000\000\000\192\000\017\000\000\000\000\000\000\003\000\016P$\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\148\187\131\232>\022\028\015\251`w\219~p\240\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\145\003\224\012\004\004\003\224`\016\000X 8\000\001\000\000\000\000\000\000\000\004\000\000\000\000\000\128\000\000\000\000\000@\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\002\000@\000\000\129\004\000\000\016\000\000\000\000\000\016 \004\000\000\b\016\000\000\001\000\000\000\000\000\000\000\000\000\000\000\128\004\000\b\000\000\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\000\004\000\000\000@\000\000\000\000\000\000\000\003\000\000\000\000\000\000\004\000\000\000\000\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\016\000\004\000\000\016 \004\000\000\b\016\000\000\001\000\000\000\000\000\132\128\"\128\b \146\028\000\025\000f\000\002\000@\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000@\000\000\000\000\016\000\004\000\000\000\016\000\000\000\000\016 \004\000\000\b\016\000\000\001\000\000\000\000\000\132\128\"\128\b \146\028\000\025\000f\000\002\000@\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\016\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000\000@\000\128\006\000\000\000\128\000\000\000\000\018\000\000\000\000\b\000`\000\000\b\000\000\000\000\001 \000\000\000\000\128\002\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\004\000\b\000\000\000\004\000\0000\000\006\000\000\012\\(\000\016\000\000\000\000\000\000\000\000\000\000@@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\001\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\001\016\000\000\000\000@\000\002\000\000\000\000\016\000\000\017\000\000\000\000\004\000\000\000\000\000\000\000\000\000\001\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000@@\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\000\000\000\000\004\000\000 \000\000\000\001\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\004\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\006\000\000\012\\ \000\016\000\000\000\000\000\133\128\162\128\b0R\028\000\025\000f\001\002\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\133\128\162\128\b R\028\000\025\000f\001\002\016@0\000\006\000\000\012\\(\000\016\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\0000\000\006\000\000\012\\ \000\016\000\000\000\000\000\133\128\"\128\b R\028\000\025\000f\001\002\016HX\n(\000\131\005!\192\001\144\006`\016!\004\000\000\000\000\000\000\000\004\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0002\016D\b\000L\018m\000\016\024\000\000\016@\003!\004@\128\004\193\"\208\001\001\128\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003!\000@\128\004\193\"\208\001\001\128\000\001\004\bH\002(\000\130\001!\128\001\144\006`\000 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\148\187\131\232>\022\028\015\249`w\139~p\244\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003!\000@\128\004\193\"\208\001\001\160\000\001\020\012IK\184>\131\225a\192\255\150\007x\183\231\015\128\000\136\003\224\012\004\004\003\224 \016\000| 0\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\128\000\001\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\128\000\001\000\000@\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000@\000\b\000\000\016\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \146\028\000\017\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\002\000@\000\000\129\004\000\000\016\000\000\000\000\000\016 \004\000\000\b\016\000\000\001\000\000\000\000\000\132\128\"\128\b \146\028\000\017\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\128\004\000@\000\000\004\000\000\000\000\000\000\000\000\016\000\000\004\000\004\000@\000\000\000\000\000\000\000\001\000\000\000\000\000@\004\000\000\000\000\000\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\024\000\017\000v\000\002\000\000\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\196\128\"\128\b0\018\028\000\017\000f\000\002\000\bH\002(\000\130\001!\128\001\016\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000@\000\000\000\000@\000\000\000\000\000\000\000\003\000\004\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\016\000\004\000\bH\002(\000\130\001!\128\001\016\006`\000 \004\132\128\"\128\b \018\016\000\017\000f\000\002\000@0\000\000\000\000\000\000@\000\000\000\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\001\000\000@\000\132\128\"\128\b \018\024\000\017\000f\000\002\000HH\002(\000\130\001!\000\001\016\006`\000 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\016\000\004\000\bH\002(\000\130\001!\128\001\016\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\223d@\130\2545\000\004\193\193\2388\176(4'\225\"\213\138\173\2433\208\020\015\224\000\007\142\0002\016\004\b\000L\018-\000\016\026\000\000\016@\016\000\002\000\000\000\000\004\000\000\000\000\000H\017\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\223d@\130\2545\000\004\193\193\2388\176(4'\225\"\213\138\173\2433\208\020\015\224\000\007\142\000\016 \004\004\000\b\016@\000\001\000\000\000\000\000\001\002\000@\000\000\129\004\000\000\016\000\000\000\000\000\016 \004\000\000\b\016\000\000\001\000\000\000\000\000\132\128\"\128\b \146\028\000\017\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\192\004\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\018(\000\130\001!\128\001\016\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\128\001\016\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\018\000\000\004\000\b\000`\000\000\b\000\000\000\000\001 \000\000\000\000\128\006\000\000\000\128\000\000\000\000\018\000\000\000\000\b\000 \000\000\b\000\000\000\000\132\128\"\128\012 \018\028\000\017\000v\000\006\000\000\018\000\000\000\000\b\000 \000\000\b\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\b\000\bH\002(\000\130\001!\192\001\016\006a\000!\000\001\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\132\128\"\128\b \018\028\000\017\000f\000\002\000\bH\002(\000\130\001!\128\001\016\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\192\001\016\006`\000 \000\132\128\"\128\b \018\024\000\017\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\128\"\240\024 \199\210\000\017\000`\000\002\000\bH\002(\000\130\000!\000\001\000\006`\000 \000\001\000\000\000@\000\000\004\000\000\000\000\000\000\b\000\016\000\000\004\000\000\000@\000\000\000\000\000\000\000\001\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \130\024\000\016\000f\016\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \130\024\000\016\000f\016\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\128\004\000@\000\000\004\000\000\000\000\000\000\000\0000\000@\000\000\000\000@\000\000\000\000\000\000\000\003\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\001\000\001@\000\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \130\024\000\016\000f\016\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\001\000@@\000 \193\000\000\000\016\000\000\000\000\012H\002(\000\131\000!\192\001\000\006`\000 \004\132\128\"\128\b \002\016\000\016\000f\000\002\000@0\000\000\000\000\000\000@\000\000\000\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\001\000@@\000 \193\000\000\000\016\000\000\000\000\012H\002(\000\131\000!\192\001\000\006`\000 \004\132\128\"\128\b \002\016\000\016\000f\000\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\001\000\000@\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\000!\128\001\000\006a\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\196\128\"\128\b0\002\028\000\016\000f\000\002\000\bH\002(\000\130\000!\128\001\000\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\004\004\004\002\012\016@\000\001\000\000\000\000\000\001\000@@\000 \193\004\000\000\016\000\000\000\000\000\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\196\128\"\128\b0\002\028\000\016\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000\000@\000\128\006\000\000\000\128\000\000\000\000\018\000\000\000\000\b\000`\000\000\b\000\000\000\000\001 \000\000\000\000\128\002\000\000\000\128\000\000\000\bH\002(\000\194\000!\192\001\000\006`\000`\000\b\128\000\000@\000@\006\000\000\000\000\000\000\000\000\128\000\000\004\000\004\000`\000\000\000\000\000\000\000\b\000\000\000\000\000@\006\000\000\000\000\000\000\000\000\128\000\000\000\000\004\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000 \000\000\000\000\000\000\000\002\000\000 \128\004\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\016\000\004\000 \005\016 \000\000\000\000\000\000\000\132\000\000\128\000\002\130\020\004\000\000\002\001\000\000\b@\000\b\000\000(!\000@\000\000 \016\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\128\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b@\000\b\000\000 !\000@\000\000 \016\000\000\b\000\000\000\000@@\004\000\000\000\000\000\000\000\000\128\000\000\000\004\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000@@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\b@\000\b\000\000 !\192@\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\128\000\004\000@\000\000\000\000\000\000\000\b\000\000\b\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\128\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\016\000\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\132\000\000\128\000\002\002\028\012\000\000\018\001\000\000\b@\000\b\000\000 !\128@\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b@\000\b\000\000 !\192\192\000\001 \016\000\000\001\000\000@\002\000Q\006\000\000\000\000\000\000\000\000\016\000\004\000 \005\016 \000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000@\000\000\000\000\000\000\128\001\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\016\000\000\000\016\000\004\000 \005\016 \000\000\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\004\000\000\001\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000 \000\000\000\000@\000\000\000\000\004\000\000\000\000\002\000\000\000\000\004\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002\168\000\130!!\192A\016\007`\016 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\016\000\000\000\016\000\004\000 \005\016 \000\000\000\000\000\000\000\132\128*\128\b\"\018\028\004\017\000v\001\002\000H@\000\b\000\000 !\192@\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\007\001\000\012\\`\000\016\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\b@\000\b\000\000 !\192\192\000\000 \016\000\000\132\000\000\128\000\002\002\024\004\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b@\000\b\000\000 !\128@\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\000\000\128\000\002\002\016\004\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\028\000\017\000f\000\002\000HH\002(\000\130\001!\000\001\016\006`\000 \004\b\000\000\000\000\000@\006\000\000\000\000\000\000\000\000\128\000\000\000\000\004\000 \000\000\000\000\000\000\000\000\000\000\000\000\000@\002\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\016\000\004\000 \005\016 \000\000\000\000\000\000\000\132\128\"\128\b \018\028\000\017\000f\000\002\000HH\002(\000\130\001!\000\001\016\006`\000 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000@\006\000\000\000\000\000\000\000\000\128\000\000\000\000\004\000 \000\000\000\000\000\000\000\000\000\000\000\000\000@\002\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\0000\000\007\001 \r\\ \000\016\000\000\000\000\000\133\128\170\128\b0B\028\000\017\000v\000\006\000@0\000\006\000\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\0000\000\007\001 \r\\ \000\016\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\020\000\000\000 \000\000\000\000@\000\000\000\000\004\001\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\0000\000\007\001 \r\\ \000\016\000\000\000\000\000\003\000\000`\000\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\003\000\000p\018\000\213\194\000\001\000\000\000\000\000\bX\n\168\000\131\004!\192\001\016\007`\000 \004\133\128\170\128\b0B\028\000\017\000v\000\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128*\128\b \002\028\000\016\000v\000\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\000!\128\001\000\006`\000 \004\132\128\"\128\b \002\016\000\016\000f\000\002\000@\128\000\000\000\000\004\000`\000\000\000\000\000\000\000\b\000\000\000\000\000@\002\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000 \000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\003\000\000p\018\000\213\194\000\001\000\000\000\000\000\bH\002(\000\130\000!\128\001\000\006`\000 \004\132\128\"\128\b \002\016\000\016\000f\000\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \002\016\000\016\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\000!\128\001\000\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\000!\000\001\000\006`\000 \004\002\000\000 \128\004\192\004\000\000\000\000\000\000\000\000 \000\002\b\000L\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\128\001\016\007`\016 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\128\001\016\006`\016 \004\132\128\"\128\b \018\016\000\017\000f\000\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\000!\000\001\000\006`\000 \004\002\000\000 \128\004\192\004\000\000\000\000\000\000\000\000 \000\002\b\000L\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\003 \000x\016\000\197\194\128\001\000\128 \000\016\0000\000'\001\000\012\\ \000\016\000\000\000\001@\000\000\000\000\000@@\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\133\160\"\128\b \146\026\000\017\000\230\001\002\000HH\002(\000\194\001!\192\001\016\006`\016a\004\132\128\"\128\b \018\028\000\017\000f\001\002\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\024\000\017\000f\001\002\016@\018\000\000\000\000\b\000 \000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \002\024\000\016\000f\001\002\000HH\002(\000\130\000!\000\001\000\006`\000 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\192\001\016\007`\016 \004\001 \000\b\000\000\128\002\128\000\000\128 \000\016\000\018\000\000\000\000\b\000(\000\000\b\002\000\001\000\000\000\000\000\000@@\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\194\001!\192\001\016\006`\016a\004\132\128\"\128\b \018\028\000\017\000f\001\002\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@@\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\004\000\000\000\000\000\000\000\000\136\000\000\004\000\004\000`\000\000\000\000\000\000\000\b\000\000\000\000\000@\006\000\000\000\000\000\000\000\000\128\000\000\000\000\004\000 \000\000\000\000\000\000\000\000\000\000\000\000\000@\002\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\003)\000P\144\004\193\"\176\001\001\144\000\005\004\000\016\000\004\000 \r\016 \000\000@\000\000\000\000\132\000\000\128\000\002\130\020\012\000\000\002\001\000\000\b@\000\b\000\000(!\000\192\000\000 \016\000\000\132\000\000\128\000\002\002\016\012\000\000\002\001\000\000\000\128\000\000\000\004\004\000@\000\000\000\000\000\000\128\000\000\000\000\000@@\004\000\000\000\000\000\000\000\000\000\000\000\000\004\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\002@\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b@\000\b\000\000 !\128\192\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\004\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000@@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\b@\000\b\000\000 !\192\192\000\000 \016\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\002@\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\128\000\004\000@\000\000\000\000\000\000\128\000\000\000\b\000\000@\004\000\000\000\000\000\000\000\000\000\000\000\128\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\003)\000P\144\004\193\"\176\001\001\144\000\005\004\0008\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\000\000\128\000\002\002\024\012\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\b\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\128\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\003)\000P\144\004\193\"\176\001\001\144\000\005\004\0008\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\001\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\0026\016\004X(\223\018=\000@\248\000\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000E\130\141\241'\208\004\015\128\000\001\142\0026\016\004X(\223\018=\000@\248\000\000\024\224\132\000\000\128\000\002\002\024\012\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000@\002\000\209\006\000\000\004\000\000\000\b\000\016\000\004\000 \r\016`\000\000@\000\000\000\000\001\000\000@\002\000\209\002\000\000\004\000\000\000\000\000\016\000\004\000 \r\016 \000\000@\000\000\000\000\003!\004@\200\004\193&\208\001\001\128\000\001\004\007\223d@\130\2545\000\004\193\193\2388\176(4\003!\004@\128\004\193&\208\001\001\128\000\001\004\0002\016D\b\000L\018-\000\016\024\000\000\016@\003!\000@\128\004\193\"\208\001\001\128\000\001\004\000\000\000\000\000\000\000\000\128\000\128\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000@\000\000\000\000\000\000\128\001\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\016\000\000\000\016\000\004\000 \r\016 \000\000@\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\004\000\000\001\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003)\000P\144\004\193&\176\001\001\128\000\001\004\0002\144\005\t\000L\018+\000\016\024\000\000\016@\003)\000P\144\020\193\"\176\001\001\128\000\001\004\000\016\000\004\000 \r\016 \000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000@\016\000\004\000 \r\016 \000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bZ\146\173A\138-3\251\193\016\030`\016x\212\133\169*\212\024\162\211?\188\017\001\230\001\007\141@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128*\128\b\"\018\028\012\017\000f\001\006\001@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002\168\000\130!!\192\193\016\006`\016`\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128*\128\b\"\018\028\012\017\000f\001\006\001@\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\016\000\000\000\016\000\004\000 \r\016 \000\000@\000\000\000\000\132\128*\128\b\"\018\028\012\017\000f\001\006\001@2\016D\b\000L\018-\000\016\024\000\000\016@\003!\000@\128\004\193\"\208\001\001\128\000\001\004\000\000\000\000\000\000\000\000\128\000\128\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\128\000\000\000\000@\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000p\018\000\213\194\000\001\000\000\000\000\000\b\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\000\000\128\000\002\002\028\012\000\000\002\001\000\001\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b@\000\b\000\000 !\128\192\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\004\000 \r\016 \000\000@\000\000\000\000\132\000\000\128\000\002\002\028\012\000\000\002\001\000\001\b@\000\b\000\000 !\128\192\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\007\001\000\012\\`\000\016\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\b@\000\b\000\000 !\128\192\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\000\000\128\000\002\002\024\012\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b@\000\b\000\000 !\000\192\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\192\001\016\006`\000 \004\003\000\000p\018\000\213\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\001\000\000@\002\000\209\002\000\000\004\000\000\000\000\bH\002(\000\130\001!\192\001\016\006`\000 \004\003)\000P\144\004\193\"\176\001\001\144\000\005\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\024\000\017\000f\000\002\000HH\002(\000\130\001!\000\001\016\006`\000 \004\b\000\000\000\000\000@\006\000\000\000\000\000\000\000\000\128\000\000\000\000\004\000 \000\000\000\000\000\000\000\000\000\000\000\000\000@\002\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\003)\000P\144\004\193\"\176\001\001\144\000\005\004\bH\002(\000\130\001!\128\001\016\006`\000 \004\132\128\"\128\b \018\016\000\017\000f\000\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\016\000\016\000f\000\002\000\0002\016D\012\000L\018m\000\016\024\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\016\000\017\000f\000\002\000HH\002(\000\130\001!\128\001\016\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\000\001\016\006`\000 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\024\000\016\000f\000\002\000\bH\002(\000\130\001!\000\001\000\006`\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\016\000\025\000f\000\002\000@\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\128\001\000\006`\000 \000\132\128\"\128\b \018\016\000\016\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\128*\128\b0\146\028\000\017\000v\000\"\000L\000\000\128\000\001\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\004\000\000\000\000\000L\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\128\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b@\000\b\000\000 !\000\192\000\000 \016\000\000\128\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\129\002\000@@\000\129\004\000\000\016\000\000\000\000\000\016 \004\000\000\b\016@\000\001\000\000\000\000\000\001\002\000@\000\000\129\000\000\000\016\000\000\000\000\000\000\000\128\000\000\b\000@\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\016\004\004\000\002\012\016\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\128\000\001\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\128\000\000\000\000\000\000\000\000\000\002@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b2\016\004\b\000L\018-\000\016\026\000\000\017@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012IK\184>\131\225a\192\255\150\007x\183\231\015\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\001 \000\b\000\000\128\002\000\000\000\128\000\000\016\000\018\000\000\000\000\b\000 \000\000\b\000\000\001\000\001 \000\000\000\000\128\002\000\000\000\128\000\000\000\bH\002(\000\194\001!\192\001\016\007`\000a\000\001 \000\000\000\000\128\002\000\000\000\128\000\000\000\bH\002(\000\130\001!\192\001\016\006`\000!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\128\001\016\006`\000!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\194\001!\192\001\016\007`\000a\000\001 \000\000\000\000\128\002\000\000\000\128\000\000\000\bH\002(\000\130\001!\192\001\016\006`\000!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\132\128\"\130\b \018\024\000\017\000v\001\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\024\000\017\000f\001\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\018\000\000\128\000\b\000 \000\000\b\000\000\001\000\001 \000\000\000\000\128\002\000\000\000\128\000\000\016\bH\002(\000\130\001!\128\001\016\006`\000!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000@\000\002\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000 \000\000\000\000\0000\000\006\000\000\012\\`\000\018\000\002\000\000\000\003\000\000`\000\000\197\194\000\001 \000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\001\000\000\000\004\000\000\000\018\000\000\000\000\000\003\000\000`\000\000\197\194\000\001 \000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000@\000\000\016\000\000\000\000\004\000\000\000\016\000\000\000\000\000\001\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\b\000\000\000\000\004\000\000\000\000\000@\000\000\000\000\128\000\000\000\000@\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\b\000\000\000\000\004\000\000\000\000\000@\000\000\000\000\000\000\004\004\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\002(\000\130\001!\192\001\016\006`\016 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003 \000x\016\000\197\194\128\001\000\128 \000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \002\024\000\016\000f\001\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\018\000\000\128\000\b\000 \000\000\b\000\000\001\000\001 \000\000\000\000\128\002\000\000\000\128\000\000\016\bH\002(\000\130\000!\128\001\000\006`\000!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000@\000\000\000\000\000\000\000\000\bH\002( \130\000!\128\001\000\007`\017 \004\003 \000x\016\000\197\194\128\001\000\128 \000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \002\024\000\016\000f\001\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\018\000\000\128\000\b\000 \000\000\b\000\000\001\000\001 \000\000\000\000\128\002\000\000\000\128\000\000\016\bH\002(\000\130\000!\128\001\000\006`\000!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\b\000\000\016\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\128\"\128\b \018\028\000\017\000f\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128 \128\b \002\016\000\016\000d\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000\000\000\000\192\002\000\000\000\128\000\000\000\b\000\b\128~\002\194@\000>\"\001\004\001\130\139\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\016\000\000\000\016\000\000\000\000\012\000\000\000\000\000\000\000\000\000\128\000\128\007\224,$\000\003\226 \016@\024(\176\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000\000\000\000\128\002\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000E\130\141\241#\208\004\015\128\000\001\142\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\004\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003!\000@\128\004\193\"\208\001\001\160\000\001\004\000\000\000\000\000\000\000\000@\000\000\000@\004\129\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\016\000\000\000\000\012\000\000\000\000\000\000\000\000\000'\225 \197\138\173\2433\208\021\015\228\000\003\142\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\005\161 \128\b \210\016\016\017\000\228\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128 \128\b \018\016\000\017\000d\016\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000H\002\b\000\130\001!\000\001\000\006\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000'\225 \197\138\173\2433\208\021\015\228\000\003\142\002~\018\012X\170\2233=\001P\254@\0008\224\004\128 \128\b \018\016\000\017\000d\000\002\000\000H\002\b\000\130\001!\000\001\016\006@\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128 \128\b \018\024\000\017\000d\000\002\000\000H\002\b\000\130\001!\000\001\016\006@\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000H\002\b\000\130\001!\128\001\016\006@\000 \000\004\128 \128\b \018\016\000\017\000d\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")
and start =
- 7
+ 13
and action =
- ((16, "C\134O\006B\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\240B\154\000\000\000\000\020\004B\154C\134\025\128\005\162\003$YJ\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\170\005B\000|\000\000\001r\000\b\000\000\001j\001|\000\252\000\000\006.\002\b\005\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\244\000\000\000\000\000\000\001vd\250\000\000\000\000\0032\000\000\000\000\000\000\003J\003B\000\000\000\000m\128N\200\020\004A\028Z\132\020\004R\154O\006\020\004Lj\000\000\021P\000\000\021P\000\007\000\000\0032\000\000\000\000\000\000\003\014\000\000\021P\000\000\004&^\208Y\002b\136\000\000\128\252wd\000\000J\136D8\000\000I*\027:M \0032m\218B\154C\134\000\000\000\000O\006\020\004R\188\021P\005|t>\000\000|\194B\154C\134O\006\020\004\000\000\000\000\000\000\0164\020\184\000V\007\174\000\000\003\180\bR\000\000\000\000\000\000\020\004\000\000@\190\000\000v\254C\134\000\000\000\000NF\020\004BjT\208\000\000\001\022\000\000\000\000\002\n\000\000\000\000F\b\001\022\028\000\003\200\000&\000\000\000\000\000\017\000\000A\028\004\228\005&\019\168\020\180\020\004C\134C\134EjEj\019\168\020\180\020\180\020\004\000\000\000\000\000\000O\006\020\004\000\000\000\244\000\000T\208qjqj\000\000\tL\000\000\000}\n@\000\000\005\144\000\000\000\000 \140d\250bD\000\000d\250bD\000\000d\250d\250\007\174\000\000d\250\0032\000\000\000\000T:d\250R\172D8\006\158\001\016\000\000\001\146\000\000\005j\000\000\n\138\000\000\000\000LZ\007\174\000\000\000\000D8\007 d\250\000\000MLD8N>\000\000\000\000\000\000\006\238\000\000d\250\000\000\000\252p\200\000\000d\250\005\192d\250\000\000\023|\007H\0032\000\000\000\000\024p\000\000\007\168\000\000V\\\n\176\000\000\007Td\250\011x\000\000\011\138\000\000\004F\000\000\000\000\005\152\000\000\000\000\000\000\026\232\027\220T\208N\198\020\004T\208\000\000\002\234\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000KnEH\000\000\000\000\000\000\001\236 \224qj\000\000\000\000rv\020\004T\208\000\000\000\000P(T\208Q\148w\144\000\000W\216\000\000T\208\000\000\000\000U\184\000\000\000\000\b\026\000\000\023<\000\000\000\000w\246\000\000k:xp\000\000\128F\003$\000\000\000\000v~\000\000\011\140\000\000\000\000\023\002q\254\000\000\000\000\000\000@\000\019\168\025\248\021\142\000\000\000\000\000\000\000\000\000\028\000\000\000\000W\146\006\244\b\b\002\198d\250\000\216\bx\000\000\000\000\b\222\b\b\005\172\000\000O\006G\176Ej\019\168\020\180\005\162\003\134\000&\000\000\b\030A\028A\028\005\162\003\134\003\134A\028\000\000g \001\224\021P\tL\007<u\194\000\000d\250cDd\250[>c\218d\250\004\174d\250dp\000\000\000\000\021J\001\016[\212\bR\001\016\\\142\000\000g\182\001\224\000\000A\028hL\000\000\0078\011\022]H\000\000\000\000\000\000\000\000\000\000\0240\000\000\000\000\027\134\000\000\t\210\020\180\000\000Y\238Bb\000\000\021\196\000\000\000\000A\028\024\170\000\000\000\000\000\000\000\000X\030\000\000\003\168\000\000I\168\006B\0224\000\000\021\218M\024O\006\020\004H\194N\198\020\004\0164\0164\000\000\000\000\000\000\000\000\001\232\020ZA\168\000\000O\188PrEj\019\168\020\180\006\150A\"\000\000\029\028\000\000Q(Q\222x\214\022dd\250\006B\000\000O\006\020\004\000\000rv\020\004qjT\208@\160\000\000O\006\020\004t\168\000b\000\000T\208@\000d\250\004\168\005\172\t\014\000\000\000\000\000\000F\b\005\b\005\b\000\000\t n^\000\000rv\020\004T\208\023\002\000\000N\198\020\004\0164\021\218\0164\002\220\003\158\000\000\000\000\0164\t\030\000\000\t\138\000\000\0164\003\208\t\222\000\000!\212\000\000\002\228\000\000\000\000\025\170\000\000\017(\022\206\000\000\000\000\000\000\005~\000\000\000\000\026\158\000\000\027\146\000\000\028\134\000\000\018\028\023\194\000\000\000\000\000\000B\154\000\000\000\000\000\000\000\000\029z\000\000\030n\000\000\031b\000\000 V\000\000!J\000\000\">\000\000#2\000\000$&\000\000%\026\000\000&\014\000\000'\002\000\000'\246\000\000(\234\000\000)\222\000\000*\210\000\000+\198\000\000,\186\000\000-\174\000\000.\162\000\000/\150\020\004T\208V\230F\240\005\b\nHh\196T\208\000\000\000\000\000\000d\250\000\000\026\132j\224\000\000\024\236d\250\027x\n\018\000\000\000\000\000\000\000\000h\196\000\000\000\000\002f\011\026\000\000B\146\000\000\000\000\131\230\000\000\006\180\000\000\000\000M \005\b\n\216d\250\006\162\000\000\000\000\0046\0032\000\000d\250\0076\000\000\000\000\011`\000\000\000\000\000\000\025@d\250\007\138\000\000\000\000\027\198\000\000\000\000yP\000\000\028\028y\182\000\000\028\186z0\000\000\029\016\004l\000\000\000\000\000\000\000\000\029\174T\208\030\004n\216n\216\000\000\000\000\000\0000\138\000\000\012<\000\000\000\000\000\000i*\000\000\000\000\000}\bb\000\000\t\002\000\000\000\000X\196H\194\000\000\000\000\012\128\000\000\000\000\000\000\006\132\000\000\000\000\000\000\0164\004\196\tV\000\000\t\246\000\000\005\184\000\0001~\000\000\012\134\000\000\006\172\000\0002r\000\000\012`\007\160\000\0003fd\246\000\000\"\200\000\000\n\234\b\148\000\0004Z\000\000\012\152\t\136\000\0005N\000\000i\172\n|\000\0006B\t\198\nJ\000\000\011<\011p\000\00076\000\000\r0\012d\000\0008*\000\000\t`\rX\000\0009\030\014L\000\000:\018\015@\019\016\000\000\000\000\000\000\011\222\000\000\000\000\rN\000\000\000\000\012\180\000\000\bV\000\000\000\000\000\000\012>\000\000\012f\000\000\000\000G\216\005\b\rZn^D8\002\234\000\000\000\000n^\000\000\000\000\000\000n^\000\000\r\168\000\000\000\000\000\000\000\000\000\000\000\000;\006T\208\000\000\000\000\014&\000\000;\250\000\000<\238\000\000\030\162\000\000\000\000\n6\000\000\000\000T\208\000\000\000\000zF\011\238\000\000\000\000I\168\000\000\011\208\000\000\000\000St\000\000\r`\000\000\000\000\0022\011v\000\000\000\000\021\218\025.\tL\000\000\031\152\000\000\031\172\021\184\022\234\000\000\000\000\012\210\000\000\000\000\001\230\021FU0\000\000\024\182\000\000\b\226\000\000\000\000\rt\000\000\000\000]\236\005\188\0022\000\000\000\000\011\186\000\000\000\000\014$\000\000\000\000\000\000\019\168\020\180\004\174\000\000\000\000\021l\003\200\000&\004\\\020\180u\nA\028\020\144\020\180u\136\r\226\000\000\000\000\004\\\000\000E$\020\004\000\142\000\000\007\128\014T\000\000\014\158\000\000\000\000\003\186D8\006\168\000\000\014\148\014*M \n^d\250\0190\005\216\rx\002\252\000\000\029\012\015F\000\000\006\168\000\000\000\000\015hD8^\132\000\000e\142D8\015<D8jD_\002\b\018\015\006\000\000\000\000\020\004}:\000\000T\208n\216\000\000\000\000\015x\000\000\000\000\000\000=\226\015\172qj>\214_\174\000\000\000\000Cj\000\000\029\232\000\000C\182\000\000\025$\000\000A\028\030\016\000\000}\156\000\000\019\168\020\180}\156\000\000\025\162\020\184\000V\0032\127PA\028z\212n\216\000\000\003\200\002\212\000&\004\\n\216\129~\003\200\000&\004\\n\216\129~\000\000\000\000\004\\n\216\000\000B\154C\134T\208F4\000\000\000\000B\154C\134Ej\019\168\020\180}\156\000\000\025\128\005\162\003$\014\232d\250\t\030\015\184\127\200\000\000n\216\000\000E$\020\004\000\142s\226\007:\011\b\015\176{.\t\248\015\014\020\004n\216\000\000\020\004n\216\000\000j\224\127B\024\172\b\138\000V\001\016o\162\000\000\000V\001\016o\162\000\000\025\162\003\200\007\152\022z\001T\000\000o\162\000\000\000&\015\016A\028}z\130\192\003\200\000&\015\018A\028}z\130\192\000\000\000\000\005P\000\000h\196\000\000A\028\128\020h\196\000\000\005P\000\000N\200\020\004A\028}z\000\000E$\020\004\000\142oV\020\184\020\184\019\174\b>\000\000\012\172\021P\011V\000\000\015\168\015Z\024`\020\004Fld\250\011T\000\000VP\003v\006p\012\186\000\000\r\244\000\000\015\218\015dd\250D|\000\000\020\004\t\132\011\216\000\000\r\246\000\000\015\222\015jM \011\232d\250StD|\000\000]\228\019\206\024`\000\000\016\002\tF\000V\000\000\r2\024`d\250\012>\014\n\0128\014\016\000\000\000\000d\250\b\194\003\254\000\000\000\000kT\000\000\000\000\014&\024`k\210D|\000\000\020\004d\250\012\214d\250S\252D|\000\000\011x\000\000\000\000D|\000\000\000\000VP\000\000n\216\129\130\019\174\b>\012\172\015\242\015\164\024`n\216\129\130\000\000\000\000\019\174\b>\012\172\016\000\015\142N\018f\012D8\016\022N\018d\250\003\254\016(N\018D8\016*N\018\r\002\0144lPl\206\000\000~\028\000\000\000\000n\216\130\206\019\174\b>\012\172\016 \015\172N\018n\216\130\206\000\000\000\000\000\000\127B\000\000\000\000\000\000\000\000\000\000\000\000h\196\000\000\129\252\020\004\021P\0160t>\000\000|\194\129\252\000\000\000\000\131N\020\004\021P\0166\015\198Y\002m\128\006\168\016r\000\000\000\000mFoV\020\004\000\000{\166\000\142\000\000\000\000o\162\131N\000\000\000\000\000\000v\006EZO\200\006\168\016t\000\000\000\000\000\000oV\020\004\000\000\006\168\016\132\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003v\020\184\019\174\b>\012\172\016lo\198B\178\020\004BjG\130\026\158\002\252\006\168\016r\003\198\000\000\000\000\016$\000\000\000\000F\224\000\000\n$\014H\000\000\014\146\000\000\016z\016\004d\250Wn\016~\004<\000\000\000\000\0166\000\000\000\000\029b\bf\r\162\000\000\016\150ph~J\005\b\0168d\250\012\238\000\000\000\000\016N\000\000\000\000\000\000F\224\000\000\nx\014\132\000\000\014\230\000\000\016\190\016HM \000\000\016\206q\n\132*\005\b\016ld\250\r<\000\000\000\000\016~\000\000\000\000\000\000\020\004\000\000F\224\000\000\020&\019\206B\178B\178r\240B\154\020\004}:T\208\007V\000\000\n:\000V\000\000\014\132B\178d\250\r>\007\174\000\000\020\004U\184o\198B\178\011\226B\178\000\000DfEH\000\000`B\000\000\000\000`\218\000\000\000\000ar\000\000\014\160B\178b\n}:T\208\007V\000\000\000\"\000\000\000\000N\018\014X\000\000\000\000L\028\016\214\000\000F\224\000\000B\178L\028F\224\000\000\020\004d\250F\224\000\000\014\148\000\000\000\000F\224\000\000\000\000G\130\000\000~vN\018\016\136B\178~\246o\198\000\000n\216\130t\019\174\b>\012\172\016\230o\198n\216\130t\000\000\000\000\000\000\131\\O\006\000\000\000\000\000\000\000\000\000\000\000\000\128\140n\216\000\000\129\252\000\000\000\000\000\000\000\000h\196\131\\\000\000\017\030\000\000\000\000\128\140\017&\000\000h\196\131\\\000\000\000\000\014\244\000\000\000\000f\138\026@\000\000\000\000@\160\000\000d\250\012H\000\000G\130\015H\000\000\000\000\000\000\014\172\000\000\000\000\000\000Ej\019\168\020\180\004\174\000\000Fz\000\000\030\220\000\000\001\180\000\000\000\000\0170\000\000\017Zv~\000\000?\202\017B\000\000\000\000\0178\0268\022h\000\142sj\007:\020\004\000\000n\216\000\000\000\000\000\000\000\000\000\000\000\000\000\000s|\007:\020\004\000\000\014\254t>\000\000|\194\000\000\017:\0268\022hn\216\000\000\017J\000\000\006\162\015D\020\004K\150\000\000\000\000\028F\132\\\000\000\000\000\016\226\000\000\0176d\250\000\000\r\144\t\150\007\174\000\000\000\000d\250\t\b\n\210\000\000d\250\n\240\006\168\017^\000\000\000\000{\170\000\000\000\000Y\002\000\000o\162\000\000\017\\\0268\023\\h\196\000\000\000\000\000\000\000\000\015(t>Y\002\000\000o\162\000\000\017^\0268\023\\h\196\000\000\015p\000\000\000\000\031\004\000\000n\216\000\000\017z\000\000\000\000\016\246\000\000\017\000\000\000\017\020\000\000\000\000K \017\022\000\000\000\000d\250\000\000\014\156\000\000\000\000\017\024\000\000\000\000T\208\031\150\000\000\000\000H\194\0032|h\000\000\000\000\000\000\000\000\000\000rh\023l\000\000\000\000\017\172\000\000JV\000\000\015\128\017\184\000\000\017\196\000\000I\168I\168\132>\132>\000\000\000\000nz\132>\000\000\000\000\000\000nz\132>\0178\000\000\017>\000\000"), (16, "\b\193\b\193\000\006\002.\006\005\b\193\002\154\002\158\b\193\002\202\002\214\b\193\003r\b\193\006n\002\218\b\193\023\138\b\193\b\193\b\193\0022\b\193\b\193\006\005\003f\003j\002\222\b\193\003\030\003\"\t\190\b\193\011\238\b\193\003\234\003&\023\142\002\226\006\202\b\193\b\193\003\178\003\182\b\193\003\186\003\014\003\198\003\206\006\170\004-\b\193\b\193\002\146\001v\b\182\003\026\b\193\b\193\b\193\007\234\007\238\007\250\b\014\001*\005R\b\193\b\193\b\193\b\193\b\193\b\193\b\193\b\193\b\193\b\130\000\238\b\193\015N\b\193\b\193\002b\b\142\b\166\b\250\005^\005b\b\193\b\193\b\193\004-\b\193\b\193\b\193\b\193\b\186\b\214\r\186\b\193\003v\b\193\b\193\000\238\b\193\b\193\b\193\b\193\b\193\b\193\005f\b\002\b\193\b\193\b\193\b\026\004.\t\014\015R\b\193\b\193\b\193\b\193\012e\012e\023\146\006r\006\r\012e\003}\012e\012e\015^\012e\012e\012e\012e\004R\012e\012e\0069\012e\012e\012e\001\206\012e\012e\006\r\012e\004-\012e\012e\012e\012e\012e\012e\012e\012e\015f\001j\0069\012e\004\190\012e\012e\012e\012e\012e\000\238\012e\012e\017\198\012e\003\202\012e\012e\012e\001\134\001\206\012e\012e\012e\012e\012e\012e\012e\000\238\012e\012e\012e\012e\012e\012e\012e\012e\012e\012e\012e\003}\012e\012e\001f\012e\012e\003U\003>\001r\004-\012e\012e\012e\012e\012e\001\130\012e\012e\012e\012e\012e\0252\012e\012e\004Z\012e\012e\003B\012e\012e\012e\012e\012e\012e\012e\012e\012e\012e\012e\012e\012e\0256\004-\012e\012e\012e\012e\001\153\001\153\001\153\004N\006\246\001\153\001\182\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\186\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\0072\b\157\001\153\001\146\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\198\001\153\001\153\001\153\004^\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\006E\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\n\154\001\153\001\153\n\166\003J\006E\007\242\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\014\150\b2\001\153\005\146\001\153\001\153\003N\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\001\153\b\157\001\153\001\153\001\153\001\153\001\153\t\245\t\245\003f\003j\tb\t\245\003J\t\245\t\245\003y\t\245\t\245\t\245\t\245\001\206\t\245\t\245\016\170\t\245\t\245\t\245\001b\t\245\t\245\tf\t\245\003N\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\001z\006\026\001\138\t\245\004-\t\245\t\245\t\245\t\245\t\245\002F\t\245\t\245\r\138\t\245\001\214\t\245\t\245\t\245\002z\004-\t\245\t\245\t\245\t\245\t\245\t\245\t\245\004-\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\000\238\t\245\t\245\003y\t\245\t\245\004-\001\002\001\190\004v\t\245\t\245\t\245\t\245\t\245\001\218\t\245\t\245\t\245\t\245\t&\006\134\tV\t\245\007\137\t\245\t\245\001\230\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\t\245\004-\t\245\t\245\t\245\t\245\t\245\003\153\003\153\004-\004-\006\230\003\153\002J\003\153\003\153\006\198\003\153\003\153\003\153\003\153\000\238\003\153\003\153\004-\003\153\003\153\003\153\t*\003\153\003\153\015n\003\153\007\174\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\r6\001\234\rB\003\153\000\238\003\153\003\153\003\153\003\153\003\153\bU\003\153\003\153\003!\003\153\001\206\003\153\003\153\003\153\007\230\000\238\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003!\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\011&\t\030\tN\011\150\003\153\003\153\005\"\000\238\002\246\021\194\003\153\003\153\003\153\003\153\003\153\002V\003\153\003\153\003\153\003\153\t&\015\206\tV\003\153\n\154\003\153\003\153\n\166\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\003\153\006\198\003\153\003\153\003\153\003\153\003\153\003\141\003\141\001\002\001\190\bU\003\141\003\237\003\141\003\141\025\026\003\141\003\141\003\141\003\141\b\137\003\141\003\141\005&\003\141\003\141\003\141\022\n\003\141\003\141\003~\003\141\011.\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\007\174\n\154\015\022\003\141\n\166\003\141\003\141\003\141\003\141\003\141\000\238\003\141\003\141\000\238\003\141\004\178\003\141\003\141\003\141\005\161\015\030\003\141\003\141\003\141\003\141\003\141\003\141\003\141\014\254\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\237\t\030\tN\007&\003\141\003\141\b\230\001f\003U\003\130\003\141\003\141\003\141\003\141\003\141\004b\003\141\003\141\003\141\003\141\t&\025\030\tV\003\141\001\206\003\141\003\141\003\246\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\006\198\003\141\003\141\003\141\003\141\003\141\tq\tq\b\153\003\250\006\021\tq\005.\tq\tq\005\161\tq\tq\tq\tq\006\181\tq\tq\002\182\tq\tq\tq\014\202\tq\tq\006\021\tq\004-\tq\tq\tq\tq\tq\tq\tq\tq\004-\004-\018\n\tq\004-\tq\tq\tq\tq\tq\t\138\tq\tq\000\238\tq\012N\tq\tq\tq\001\150\018\022\tq\tq\tq\tq\tq\tq\tq\000\238\tq\tq\tq\tq\tq\tq\tq\tq\tq\tq\tq\000\238\tq\tq\001f\tq\tq\b\153\003U\006\166\004-\tq\tq\tq\tq\tq\nn\tq\tq\tq\tq\tq\018\162\tq\tq\004.\tq\tq\012&\tq\tq\tq\tq\tq\tq\tq\tq\tq\tq\tq\tq\tq\007\242\004-\tq\tq\tq\tq\ti\ti\004\206\012*\n\254\ti\000\238\ti\ti\018\170\ti\ti\ti\ti\004-\ti\ti\005\137\ti\ti\ti\003q\ti\ti\011\002\ti\014\210\ti\ti\ti\ti\ti\ti\ti\ti\007\174\b~\015v\ti\004N\ti\ti\ti\ti\ti\005\129\ti\ti\000\238\ti\012f\ti\ti\ti\000\238\004\174\ti\ti\ti\ti\ti\ti\ti\000\238\ti\ti\ti\ti\ti\ti\ti\ti\ti\ti\ti\004-\ti\ti\002\158\ti\ti\002\214\006~\006\150\011\026\ti\ti\ti\ti\ti\004f\ti\ti\ti\ti\ti\bV\ti\ti\004\138\ti\ti\004\222\ti\ti\ti\ti\ti\ti\ti\ti\ti\ti\ti\ti\ti\004N\017V\ti\ti\ti\ti\ty\ty\003f\017\190\002n\ty\000\238\ty\ty\017Z\ty\ty\ty\ty\002\158\ty\ty\017\210\ty\ty\ty\002\194\ty\ty\004\178\ty\b\137\ty\ty\ty\ty\ty\ty\ty\ty\005b\0116\004E\ty\007\002\ty\ty\ty\ty\ty\007n\ty\ty\000\238\ty\012z\ty\ty\ty\002\238\007\n\ty\ty\ty\ty\ty\ty\ty\000\238\ty\ty\ty\ty\ty\ty\ty\ty\ty\ty\ty\005\n\ty\ty\011Z\ty\ty\005\238\004E\018b\b\137\ty\ty\ty\ty\ty\015V\ty\ty\ty\ty\ty\002\250\ty\ty\006\130\ty\ty\rR\ty\ty\ty\ty\ty\ty\ty\ty\ty\ty\ty\ty\ty\000\238\b\137\ty\ty\ty\ty\tY\tY\002\209\004-\012\153\tY\006\146\tY\tY\004-\tY\tY\tY\tY\002\254\tY\tY\012\153\tY\tY\tY\011\242\tY\tY\004-\tY\000\n\tY\tY\tY\tY\tY\tY\tY\tY\012\014\000\238\012\030\tY\014\174\tY\tY\tY\tY\tY\bY\tY\tY\006\210\tY\012\154\tY\tY\tY\002\209\011\250\tY\tY\tY\tY\tY\tY\tY\rV\tY\tY\tY\tY\tY\tY\tY\tY\tY\tY\tY\011\254\tY\tY\bm\tY\tY\b\210\000\238\006\158\016\022\tY\tY\tY\tY\tY\b\242\tY\tY\tY\tY\tY\004-\tY\tY\002\158\tY\tY\012&\tY\tY\tY\tY\tY\tY\tY\tY\tY\tY\tY\tY\tY\t:\000\238\tY\tY\tY\tY\ta\ta\018\206\r\002\bY\ta\000\238\ta\ta\014\178\ta\ta\ta\ta\001\206\ta\ta\003\226\ta\ta\ta\012>\ta\ta\018\214\ta\000\238\ta\ta\ta\ta\ta\ta\ta\ta\012V\017.\012n\ta\bm\ta\ta\ta\ta\ta\007\181\ta\ta\tB\ta\012\174\ta\ta\ta\002z\012F\ta\ta\ta\ta\ta\ta\ta\002\250\ta\ta\ta\ta\ta\ta\ta\ta\ta\ta\ta\012J\ta\ta\007\162\ta\ta\019\022\021\226\006\198\026\"\ta\ta\ta\ta\ta\tR\ta\ta\ta\ta\ta\004-\ta\ta\002\250\ta\ta\017f\ta\ta\ta\ta\ta\ta\ta\ta\ta\ta\ta\ta\ta\n\134\021\234\ta\ta\ta\ta\t\153\t\153\022n\005\129\012\206\t\153\003\234\t\153\t\153\011&\t\153\t\153\t\153\t\153\004b\t\153\t\153\003\238\t\153\t\153\t\153\012\210\t\153\t\153\022v\t\153\000\238\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\012\230\n\190\012\250\t\153\r\254\t\153\t\153\t\153\t\153\t\153\007\173\t\153\t\153\005\002\t\153\012\194\t\153\t\153\t\153\004j\tb\t\153\t\153\t\153\t\153\t\153\t\153\t\153\026:\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\012\150\t\153\t\153\bq\t\153\t\153\023\002\015\138\014\006\007r\t\153\t\153\t\153\t\153\t\153\003\018\t\153\t\153\t\153\t\153\t\153\011\250\t\153\t\153\n\226\t\153\t\153\000\238\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\t\153\012\218\000\238\t\153\t\153\t\153\t\153\t\137\t\137\001\218\014R\019\150\t\137\018\146\t\137\t\137\018r\t\137\t\137\t\137\t\137\006.\t\137\t\137\b\133\t\137\t\137\t\137\011\018\t\137\t\137\026>\t\137\005\018\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\005\026\0062\014\218\t\137\bq\t\137\t\137\t\137\t\137\t\137\000\238\t\137\t\137\014.\t\137\012\222\t\137\t\137\t\137\n\222\012F\t\137\t\137\t\137\t\137\t\137\t\137\t\137\014\026\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\r2\t\137\t\137\018\210\t\137\t\137\011B\014V\014\030\011&\t\137\t\137\t\137\t\137\t\137\002J\t\137\t\137\t\137\t\137\t\137\019\154\t\137\t\137\007\189\t\137\t\137\011\210\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\t\137\014\222\004\178\t\137\t\137\t\137\t\137\t\129\t\129\011\214\019.\004\178\t\129\024\226\t\129\t\129\0236\t\129\t\129\t\129\t\129\012\022\t\129\t\129\012^\t\129\t\129\t\129\012v\t\129\t\129\004N\t\129\011\210\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\018\238\012\026\0142\t\129\012b\t\129\t\129\t\129\t\129\t\129\000\238\t\129\t\129\012\170\t\129\012\242\t\129\t\129\t\129\nn\014\138\t\129\t\129\t\129\t\129\t\129\t\129\t\129\rJ\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\0196\t\129\t\129\014\142\t\129\t\129\rb\018\166\002\233\019B\t\129\t\129\t\129\t\129\t\129\005\145\t\129\t\129\t\129\t\129\t\129\018j\t\129\t\129\rj\t\129\t\129\012\022\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\t\129\000\238\012^\t\129\t\129\t\129\t\129\t\145\t\145\012\238\004N\014B\t\145\000\238\t\145\t\145\023\026\t\145\t\145\t\145\t\145\014\186\t\145\t\145\r>\t\145\t\145\t\145\r~\t\145\t\145\019\130\t\145\014F\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\015\154\022J\014\190\t\145\003e\t\145\t\145\t\145\t\145\t\145\000\238\t\145\t\145\026\030\t\145\r\006\t\145\t\145\t\145\020*\019\"\t\145\t\145\t\145\t\145\t\145\t\145\t\145\022*\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\022\170\t\145\t\145\007B\t\145\t\145\r\174\018\174\018\218\007\173\t\145\t\145\t\145\t\145\t\145\019B\t\145\t\145\t\145\t\145\t\145\001\206\t\145\t\145\004b\t\145\t\145\014\230\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\t\145\r\218\004b\t\145\t\145\t\145\t\145\t\225\t\225\014\234\005\141\007\185\t\225\023\154\t\225\t\225\026.\t\225\t\225\t\225\t\225\019\n\t\225\t\225\019:\t\225\t\225\t\225\0152\t\225\t\225\015Z\t\225\023\158\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\020.\023\218\021\230\t\225\021\238\t\225\t\225\t\225\t\225\t\225\012\161\t\225\t\225\024\254\t\225\r\018\t\225\t\225\t\225\022r\019f\t\225\t\225\t\225\t\225\t\225\t\225\t\225\015b\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\012\173\t\225\t\225\007B\t\225\t\225\022z\005\133\015~\024\186\t\225\t\225\t\225\t\225\t\225\015\130\t\225\t\225\t\225\t\225\t\225\001\206\t\225\t\225\000\238\t\225\t\225\023\014\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\023n\001\206\t\225\t\225\t\225\t\225\003\137\003\137\007\177\007B\024\238\003\137\023\222\003\137\003\137\027\031\003\137\003\137\003\137\003\137\025\178\003\137\003\137\007B\003\137\003\137\003\137\025\230\003\137\003\137\026\194\003\137\015\170\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\026\150\015\190\025\002\003\137\015\214\003\137\003\137\003\137\003\137\003\137\015\234\003\137\003\137\016\018\003\137\004E\003\137\003\137\003\137\024\190\016&\003\137\003\137\003\137\003\137\003\137\003\137\003\137\017&\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\0172\t\030\tN\003\218\003\137\003\137\005\234\004\193\017\218\017\242\003\137\003\137\003\137\003\137\003\137\002\194\003\137\003\137\003\137\003\137\t&\024\242\tV\003\137\018z\003\137\003\137\018~\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\003\137\026\198\003\137\003\137\003\137\003\137\003\137\001\221\001\221\018\182\018\186\018\226\001\221\018\230\002\158\001\221\019\018\002\214\001\221\t6\001\221\019\202\002\218\001\221\019\206\001\221\001\221\001\221\019\242\001\221\001\221\019\246\t>\020\006\002\222\001\221\001\221\001\221\001\221\001\221\tF\001\221\020\022\020\"\020^\002\226\020b\001\221\001\221\001\221\001\221\001\221\020\174\003\014\001\190\020\214\001\221\020\218\001\221\001\221\002\146\020\234\021:\003\026\001\221\001\221\001\221\007\234\007\238\007\250\021Z\0122\005R\001\221\001\221\001\221\001\221\001\221\001\221\001\221\001\221\001\221\021\154\t\030\tN\021\190\001\221\001\221\021\206\021\246\021\250\022\006\005^\005b\001\221\001\221\001\221\022\022\001\221\001\221\001\221\001\221\012:\0222\012\138\001\221\022B\001\221\001\221\022V\001\221\001\221\001\221\001\221\001\221\001\221\005f\b\002\001\221\001\221\001\221\b\026\004.\022\130\022\134\001\221\001\221\001\221\001\221\t\201\t\201\022\146\022\162\022\182\t\201\023\170\002\158\t\201\024\002\002\214\t\201\t\201\t\201\024*\002\218\t\201\024\146\t\201\t\201\t\201\024\162\t\201\t\201\025>\t\201\025F\002\222\t\201\t\201\t\201\t\201\t\201\t\201\t\201\025V\025b\025\198\002\226\025\218\t\201\t\201\t\201\t\201\t\201\026\n\003\014\001\190\026\018\t\201\026N\t\201\t\201\002\146\026v\026\174\003\026\t\201\t\201\t\201\007\234\007\238\007\250\026\222\t\201\005R\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\026\234\t\201\t\201\026\242\t\201\t\201\026\251\027\011\027+\027w\005^\005b\t\201\t\201\t\201\027\139\t\201\t\201\t\201\t\201\t\201\027\147\t\201\t\201\027\207\t\201\t\201\027\215\t\201\t\201\t\201\t\201\t\201\t\201\005f\b\002\t\201\t\201\t\201\b\026\004.\000\000\000\000\t\201\t\201\t\201\t\201\t\197\t\197\000\000\000\000\000\000\t\197\000\000\002\158\t\197\000\000\002\214\t\197\t\197\t\197\000\000\002\218\t\197\000\000\t\197\t\197\t\197\000\000\t\197\t\197\000\000\t\197\000\000\002\222\t\197\t\197\t\197\t\197\t\197\t\197\t\197\000\000\000\000\000\000\002\226\000\000\t\197\t\197\t\197\t\197\t\197\000\000\003\014\001\190\000\000\t\197\000\000\t\197\t\197\002\146\000\000\000\000\003\026\t\197\t\197\t\197\007\234\007\238\007\250\000\000\t\197\005R\t\197\t\197\t\197\t\197\t\197\t\197\t\197\t\197\t\197\000\000\t\197\t\197\000\000\t\197\t\197\000\000\000\000\000\000\000\000\005^\005b\t\197\t\197\t\197\000\000\t\197\t\197\t\197\t\197\t\197\000\000\t\197\t\197\000\000\t\197\t\197\000\000\t\197\t\197\t\197\t\197\t\197\t\197\005f\b\002\t\197\t\197\t\197\b\026\004.\000\000\000\000\t\197\t\197\t\197\t\197\002)\002)\000\000\000\000\000\000\002)\000\000\002\158\002)\000\000\002\214\002)\t6\002)\000\000\002\218\002)\000\000\002)\002)\002)\000\000\002)\002)\000\000\t>\000\000\002\222\002)\002)\002)\002)\002)\tF\002)\007\161\000\000\000\000\002\226\007\161\002)\002)\002)\002)\002)\000\000\003\014\001\190\000\000\002)\000\000\002)\002)\002\146\000\000\000\000\003\026\002)\002)\002)\007\234\007\238\007\250\000\000\0122\005R\002)\002)\002)\002)\002)\002)\002)\002)\002)\007\161\004\149\002)\000\000\002)\002)\000\000\000\000\004-\000\000\005^\005b\002)\002)\002)\004-\002)\002)\002)\002)\006R\007\161\000\000\002)\004\149\002)\002)\004-\002)\002)\002)\002)\002)\002)\005f\b\002\002)\002)\002)\b\026\004.\000\000\000\000\002)\002)\002)\002)\004-\000\000\004-\000\000\004-\004-\004-\004-\004-\004-\004-\004\218\004-\000\238\004-\004-\000\238\004-\004-\004-\004-\004-\004-\004-\004-\004-\004-\004-\000\000\004-\004-\000\000\000\238\004-\004-\004-\004-\004-\004-\004-\004-\000\000\004-\004-\004-\004-\004-\004-\004-\004-\002\250\004-\004-\004-\004-\004-\004-\004-\004-\000\238\004-\004-\004-\004-\004-\004-\004-\004-\000\000\000\000\004-\006\242\000\000\004-\004-\004-\000\238\004-\000\000\000\000\004-\004-\004-\004-\004-\004-\004-\004-\004-\b6\001\190\004-\004-\003\170\002\209\002\158\004-\002\209\018V\014\"\004-\004-\003\138\0146\014J\014Z\000\000\000\000\004-\004-\004-\007^\000\000\004-\004-\004-\004-\000\000\000\129\004-\000\129\000\n\000\129\000\129\000\129\000\129\000\129\000\129\000\129\000\238\000\129\022\214\000\129\000\129\003\166\000\129\000\129\002\209\000\000\000\129\000\129\002\146\000\129\000\129\000\000\000\129\000\000\000\129\000\129\002\209\002\209\000\129\000\129\000\000\000\129\000\129\000\129\000\000\000\129\015&\000\129\000\129\000\129\000\129\000\129\000\129\000\129\000\129\002\250\006\190\000\129\000\129\012Q\012=\000\129\000\129\000\000\000\129\000\129\000\129\000\129\000\129\000\129\000\129\000\129\000\129\002\209\002\209\000\000\000\000\012Q\000\129\000\000\000\129\000\000\000\129\002\026\006\133\000\000\000\129\000\129\000\129\000\129\000\129\000\129\000\129\000\129\b6\014\154\002\"\000\129\000\n\002&\012=\000\000\000\222\006Z\014\"\b\177\000\129\006\133\0146\014J\014Z\007\186\000\129\000\129\000\129\000\129\000\000\000\000\000\129\000\129\000\129\000\129\002\025\002\025\014z\000\000\002\209\002\025\b\177\002\158\002\025\007\190\002\214\002\025\000\000\002\025\000\000\002\218\002\025\007:\002\025\002\025\002\025\000\000\002\025\002\025\000\000\007B\000\000\002\222\002\025\002\025\002\025\002\025\002\025\007F\002\025\007\174\000\000\000\000\002\226\000\000\002\025\002\025\002\025\002\025\002\025\006\157\003\014\007\254\000\238\002\025\000\000\002\025\002\025\002\146\000\000\000\000\003\026\002\025\002\025\002\025\007\234\007\238\007\250\000\000\006\157\005R\002\025\002\025\002\025\002\025\002\025\002\025\002\025\002\025\002\025\000\000\t\030\tN\015N\002\025\002\025\002b\000\000\000\000\000\000\005^\005b\002\025\002\025\002\025\000\000\002\025\002\025\002\025\002\025\t&\007\194\tV\002\025\000\000\002\025\002\025\000\000\002\025\002\025\002\025\002\025\002\025\002\025\005f\b\002\002\025\002\025\002\025\b\026\004.\000\000\015R\002\025\002\025\002\025\002\025\0025\0025\006\157\000\000\0059\0025\007E\000\000\0025\015^\000\000\0025\007\246\0025\b\181\000\000\0025\000\000\0025\0025\0025\002\158\0025\0025\000\000\000\000\b\165\000\000\0025\0025\0025\0025\0025\000\000\0025\015f\007E\b\181\000\000\000\000\0025\0025\0025\0025\0025\006:\000\000\0059\b\165\0025\007E\0025\0025\007E\bv\005\246\000\000\0025\0025\0025\007E\003\226\025j\017\194\007E\0059\0025\0025\0025\0025\0025\0025\0025\0025\0025\005\250\t\030\tN\015N\0025\0025\002b\000\000\000\000\000\000\000\238\002\250\0025\0025\0025\000\000\0025\0025\0025\0025\t&\000\000\tV\0025\000\000\0025\0025\000\000\0025\0025\0025\0025\0025\0025\bA\000\000\0025\0025\0025\000\238\t\n\000\000\015R\0025\0025\0025\0025\0021\0021\000\000\001\002\001\190\0021\000\000\005\254\0021\015^\005\194\0021\000\000\0021\000\000\b\165\0021\006\n\0021\0021\0021\006\022\0021\0021\bA\000\000\000\000\000\000\0021\0021\0021\0021\0021\000\000\0021\015f\005\254\000\000\000\000\005\194\0021\0021\0021\0021\0021\bA\006\n\000\000\000\000\0021\006\022\0021\0021\000\000\000\000\007\142\006\242\0021\0021\0021\000\000\000\000\021\006\000\000\000\000\000\000\0021\0021\0021\0021\0021\0021\0021\0021\0021\007\146\t\030\tN\bA\0021\0021\000\000\004\218\000\000\000\000\bA\001\206\0021\0021\0021\000\000\0021\0021\0021\0021\t&\007^\tV\0021\000\000\0021\0021\000\000\0021\0021\0021\0021\0021\0021\b=\000\000\0021\0021\0021\000\238\018\130\007\202\006\242\0021\0021\0021\0021\002\029\002\029\002\209\000\000\019\n\002\029\019\014\000\000\002\029\000\000\002\146\002\029\000\000\002\029\007\206\000\000\002\029\019&\002\029\002\029\002\029\000\000\002\029\002\029\b=\000\000\000\n\012\021\002\029\002\029\002\029\002\029\002\029\000\000\002\029\007^\000\000\000\000\000\000\000\000\002\029\002\029\002\029\002\029\002\029\b=\012\021\012\021\000\000\002\029\012\021\002\029\002\029\000\238\002\209\000\000\006\242\002\029\002\029\002\029\000\000\014b\000\000\000\000\000\000\000\000\002\029\002\029\002\029\002\029\002\029\002\029\002\029\002\029\002\029\016V\t\030\tN\b=\002\029\002\029\000\000\004\218\000\000\000\000\b=\000\238\002\029\002\029\002\029\000\000\002\029\002\029\002\029\002\029\t&\007^\tV\002\029\000\000\002\029\002\029\000\000\002\029\002\029\002\029\002\029\002\029\002\029\017\142\000\000\002\029\002\029\002\029\000\238\000\000\012\021\000\000\002\029\002\029\002\029\002\029\002-\002-\002\209\002\209\016\130\002-\nM\000\000\002-\n\178\000\n\002-\000\000\002-\t\030\tN\002-\002\209\002-\002-\002-\000\000\002-\002-\000\000\002\209\002\209\000\n\002-\002-\002-\002-\002-\t&\002-\tV\nM\016Z\002\209\004\153\002-\002-\002-\002-\002-\006V\002\158\000\000\000\000\002-\nM\002-\002-\nM\011R\002\209\000\000\002-\002-\002-\nM\000\000\004\153\000\000\nM\000\000\002-\002-\002-\002-\002-\002-\002-\002-\002-\024\202\006\242\002-\007\173\002-\002-\007\173\000\000\000\000\000\000\000\000\003\226\002-\002-\002-\000\000\002-\002-\002-\002-\024\206\000\000\022*\002-\000\000\002-\002-\000\000\tn\002-\002-\002-\002-\002-\012\029\000\000\002-\002-\002-\000\000\000\000\007^\007\173\002-\002-\002-\002-\b\189\b\189\000\000\000\000\004-\b\189\012\029\012\029\b\189\007\173\012\029\b\189\000\238\b\189\000\000\000\000\t\150\000\000\b\189\t\186\b\189\000\000\b\189\b\189\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\b\189\007\173\000\000\006\153\000\000\004-\b\189\b\189\t\254\n\006\b\189\000\000\000\238\004-\000\000\b\189\000\000\n\014\b\189\000\000\000\000\000\000\006\153\b\189\b\189\000\238\006\153\000\000\007\173\000\000\000\000\000\000\b\189\b\189\t\158\t\222\n\022\n\030\n.\b\189\b\189\000\000\012\029\b\189\000\000\b\189\n6\000\000\000\000\000\000\000\000\0121\000\000\b\189\b\189\n>\000\000\b\189\b\189\b\189\b\189\000\000\000\238\0121\b\189\000\000\b\189\b\189\000\000\n^\b\189\nf\n&\b\189\b\189\012\025\000\000\b\189\nF\b\189\021\178\000\000\000\000\006\242\b\189\b\189\nN\nV\002a\002a\000\000\0121\006\153\002a\012\025\012\025\002a\000\000\012\025\002a\000\000\002a\007\154\000\000\002a\000\000\002a\002a\002a\000\000\002a\002a\000\000\000\000\000\000\000\000\002a\002a\002a\002a\002a\0121\002a\007^\0121\006\173\000\000\000\000\002a\002a\002a\002a\002a\000\000\000\238\000\000\000\000\002a\000\000\002a\002a\000\238\000\000\001*\006\173\002a\002a\002a\006\173\002\209\002\209\002\134\000\000\000\000\002a\002a\t\158\002a\002a\002a\002a\002a\002a\000\000\012\025\002a\000\000\002a\002a\000\000\000\000\000\000\000\000\000\238\000\n\002a\002a\002a\000\000\002a\002a\002a\002a\000\000\000\000\001\206\002a\000\000\002a\002a\000\000\002a\002a\002a\002a\002a\002a\025\250\000\000\002a\002a\002a\002\209\011f\000\000\000\000\002a\002a\002a\002a\002I\002I\000\000\000\000\005B\002I\000\238\011n\002I\000\000\011z\002I\000\000\002I\000\000\002z\002I\011\134\002I\002I\002I\011\146\002I\002I\000\000\000\000\000\000\000\000\002I\002I\002I\002I\002I\000\000\002I\000\000\007=\000\000\000\000\000\000\002I\002I\002I\002I\002I\004v\000\000\000\000\004\197\002I\007=\002I\002I\005\194\000\000\000\000\000\000\002I\002I\002I\007=\000\000\000\000\000\000\007=\000\000\002I\002I\t\158\002I\002I\002I\002I\002I\002I\000\000\006\242\002I\000\000\002I\002I\000\000\000\000\000\000\000\000\007U\007\157\002I\002I\002I\007\157\002I\002I\002I\002I\bb\000\000\000\000\002I\000\000\002I\002I\000\000\002I\002I\002I\002I\002I\002I\000\000\000\000\002I\002I\002I\004-\007U\007^\000\000\002I\002I\002I\002I\002U\002U\000\000\000\000\007\157\002U\000\238\007U\002U\000\000\005\194\002U\000\238\002U\004-\000\000\t\150\007U\002U\002U\002U\007U\002U\002U\000\000\007\157\000\000\000\000\002U\002U\002U\t\214\002U\000\000\002U\004-\007q\000\000\000\000\000\000\002U\002U\002U\002U\002U\000\000\000\000\000\238\000\000\002U\005\254\002U\002U\005\194\000\000\000\000\006\242\002U\002U\002U\007q\000\000\004\218\000\000\007q\000\000\002U\002U\t\158\t\222\002U\002U\002U\002U\002U\016F\006\242\002U\000\000\002U\002U\000\000\000\000\000\000\000\000\007i\000\000\002U\002U\002U\000\000\002U\002U\002U\002U\016b\007^\000\000\002U\000\000\002U\002U\022\"\002U\002U\002U\002U\002U\002U\000\000\000\000\002U\002U\002U\000\238\007i\007^\000\000\002U\002U\002U\002U\002e\002e\000\000\000\000\000\000\002e\000\238\011\170\002e\000\000\007i\002e\000\238\002e\000\000\000\000\002e\007i\002e\002e\002e\007i\002e\002e\000\000\000\000\000\000\000\000\002e\002e\002e\002e\002e\000\000\002e\000\000\0079\000\000\000\000\000\000\002e\002e\002e\002e\002e\000\000\000\000\000\000\000\000\002e\0079\002e\002e\005\194\000\000\000\000\006\242\002e\002e\002e\0079\000\000\000\000\000\000\0079\000\000\002e\002e\t\158\002e\002e\002e\002e\002e\002e\025*\006\242\002e\000\000\002e\002e\000\000\000\000\000\000\000\000\000\238\000\000\002e\002e\002e\000\000\002e\002e\002e\002e\026\206\007^\000\000\002e\000\000\002e\002e\000\000\002e\002e\002e\002e\002e\002e\000\000\000\000\002e\002e\002e\000\238\r\242\007^\000\000\002e\002e\002e\002e\002E\002E\000\000\000\000\000\000\002E\000\000\011n\002E\000\000\011z\002E\000\238\002E\000\000\000\000\002E\011\134\002E\002E\002E\011\146\002E\002E\000\000\000\000\000\000\006\189\002E\002E\002E\002E\002E\000\000\002E\000\000\000\000\006\157\000\000\000\000\002E\002E\002E\002E\002E\000\000\006\189\000\000\000\000\002E\006\189\002E\002E\000\000\000\000\000\000\006\157\002E\002E\002E\006\157\000\000\000\000\000\000\000\000\000\000\002E\002E\t\158\002E\002E\002E\002E\002E\002E\000\000\000\000\002E\000\000\002E\002E\000\000\000\000\000\000\000\000\000\238\000\000\002E\002E\002E\000\000\002E\002E\002E\002E\000\000\000\000\000\000\002E\000\000\002E\002E\000\000\002E\002E\002E\002E\002E\002E\000\000\000\000\002E\002E\002E\000\000\000\000\006\189\027;\002E\002E\002E\002E\002Q\002Q\000\000\000\000\007\246\002Q\000\000\005\254\002Q\n\154\005\194\002Q\n\166\002Q\000\000\000\000\t\150\006\n\002Q\002Q\002Q\006\022\002Q\002Q\000\000\000\000\000\000\006\149\002Q\002Q\002Q\t\214\002Q\000\000\002Q\000\000\000\000\000\000\000\000\000\000\002Q\002Q\002Q\002Q\002Q\000\000\006\149\000\000\000\000\002Q\006\149\002Q\002Q\000\000\000\000\000\000\000\000\002Q\002Q\002Q\000\000\000\000\000\000\000\000\000\000\000\000\002Q\002Q\t\158\t\222\002Q\002Q\002Q\002Q\002Q\000\000\002\250\002Q\000\000\002Q\002Q\000\000\000\000\000\000\000\000\000\000\000\000\002Q\002Q\002Q\000\000\002Q\002Q\002Q\002Q\000\000\000\000\000\000\002Q\000\000\002Q\002Q\000\000\002Q\002Q\002Q\002Q\002Q\002Q\000\000\000\000\002Q\002Q\002Q\000\000\005\150\006\149\000\000\002Q\002Q\002Q\002Q\002M\002M\000\000\003\210\000\000\002M\000\000\006\"\002M\003\222\000\000\002M\004\002\002M\000\000\000\000\t\150\000\000\002M\002M\002M\000\000\002M\002M\000\000\000\000\000\000\000\000\002M\002M\002M\t\214\002M\000\000\002M\000\000\000\000\000\000\000\000\000\000\002M\002M\002M\002M\002M\000\000\000\000\000\000\000\000\002M\000\000\002M\002M\000\000\000\000\000\000\000\000\002M\002M\002M\000\000\000\000\000\000\000\000\000\000\000\000\002M\002M\t\158\t\222\002M\002M\002M\002M\002M\000\000\002\158\002M\000\000\002M\002M\000\000\000\000\000\000\000\000\000\000\000\000\002M\002M\002M\000\000\002M\002M\002M\002M\000\000\000\000\000\000\002M\000\000\002M\002M\000\000\002M\002M\002M\002M\002M\002M\000\000\000\000\002M\002M\002M\000\000\tZ\003\226\000\000\002M\002M\002M\002M\002u\002u\000\000\000\000\000\000\002u\000\000\011\202\002u\011\218\000\000\002u\000\000\002u\000\000\000\000\t\150\000\000\002u\002u\002u\000\000\002u\002u\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002u\000\000\000\000\000\000\000\000\000\000\002u\002u\t\254\n\006\002u\000\000\000\000\000\000\000\000\002u\000\000\n\014\002u\000\000\000\000\000\000\000\000\002u\002u\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002u\002u\t\158\t\222\n\022\n\030\n.\002u\002u\000\000\002\158\002u\000\000\002u\n6\000\000\000\000\000\000\000\000\000\000\000\000\002u\002u\n>\000\000\002u\002u\002u\002u\000\000\000\000\000\000\002u\000\000\002u\002u\000\000\002u\002u\002u\n&\002u\002u\000\000\000\000\002u\nF\002u\000\000\012\142\003\226\000\000\002u\002u\nN\nV\002]\002]\000\000\000\000\000\000\002]\000\000\012\162\002]\012\182\000\000\002]\000\000\002]\000\000\000\000\t\150\000\000\002]\002]\002]\000\000\002]\002]\000\000\000\000\000\000\000\000\002]\002]\002]\t\214\002]\000\000\002]\000\000\000\000\000\000\000\000\000\000\002]\002]\002]\002]\002]\000\000\000\000\000\000\000\000\002]\000\000\002]\002]\000\000\000\000\000\000\000\000\002]\002]\002]\000\000\000\000\000\000\000\000\000\000\000\000\002]\002]\t\158\t\222\002]\002]\002]\002]\002]\000\000\000\000\002]\000\000\002]\002]\000\000\000\000\000\000\000\000\000\000\000\000\002]\002]\002]\000\000\002]\002]\002]\002]\000\000\000\000\000\000\002]\000\000\002]\002]\000\000\002]\002]\002]\002]\002]\002]\000\000\000\000\002]\002]\002]\000\000\000\000\000\000\000\000\002]\002]\002]\002]\002Y\002Y\000\000\000\000\000\000\002Y\000\000\000\000\002Y\000\000\000\000\002Y\000\000\002Y\000\000\000\000\t\150\000\000\002Y\002Y\002Y\000\000\002Y\002Y\000\000\000\000\000\000\000\000\002Y\002Y\002Y\t\214\002Y\000\000\002Y\000\000\000\000\000\000\000\000\000\000\002Y\002Y\002Y\002Y\002Y\000\000\000\000\000\000\000\000\002Y\000\000\002Y\002Y\000\000\000\000\000\000\000\000\002Y\002Y\002Y\000\000\000\000\000\000\000\000\000\000\000\000\002Y\002Y\t\158\t\222\002Y\002Y\002Y\002Y\002Y\000\000\000\000\002Y\000\000\002Y\002Y\000\000\000\000\000\000\000\000\000\000\000\000\002Y\002Y\002Y\000\000\002Y\002Y\002Y\002Y\000\000\000\000\000\000\002Y\000\000\002Y\002Y\000\000\002Y\002Y\002Y\002Y\002Y\002Y\000\000\000\000\002Y\002Y\002Y\000\000\000\000\000\000\000\000\002Y\002Y\002Y\002Y\002m\002m\000\000\000\000\000\000\002m\000\000\000\000\002m\000\000\000\000\002m\000\000\002m\000\000\000\000\t\150\000\000\002m\002m\002m\000\000\002m\002m\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\002m\000\000\002m\000\000\000\000\000\000\000\000\000\000\002m\002m\t\254\n\006\002m\000\000\000\000\000\000\000\000\002m\000\000\002m\002m\000\000\000\000\000\000\000\000\002m\002m\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002m\002m\t\158\t\222\n\022\n\030\002m\002m\002m\000\000\000\000\002m\000\000\002m\002m\000\000\000\000\000\000\000\000\000\000\000\000\002m\002m\002m\000\000\002m\002m\002m\002m\000\000\000\000\000\000\002m\000\000\002m\002m\000\000\002m\002m\002m\n&\002m\002m\000\000\000\000\002m\002m\002m\000\000\000\000\000\000\000\000\002m\002m\002m\002m\002A\002A\000\000\000\000\000\000\002A\000\000\000\000\002A\000\000\000\000\002A\000\000\002A\000\000\000\000\t\150\000\000\002A\002A\002A\000\000\002A\002A\000\000\000\000\000\000\000\000\002A\002A\002A\t\214\002A\000\000\002A\000\000\000\000\000\000\000\000\000\000\002A\002A\002A\002A\002A\000\000\000\000\000\000\000\000\002A\000\000\002A\002A\000\000\000\000\000\000\000\000\002A\002A\002A\000\000\000\000\000\000\000\000\000\000\000\000\002A\002A\t\158\t\222\002A\002A\002A\002A\002A\000\000\000\000\002A\000\000\002A\002A\000\000\000\000\000\000\000\000\000\000\000\000\002A\002A\002A\000\000\002A\002A\002A\002A\000\000\000\000\000\000\002A\000\000\002A\002A\000\000\002A\002A\002A\002A\002A\002A\000\000\000\000\002A\002A\002A\000\000\000\000\000\000\000\000\002A\002A\002A\002A\002=\002=\000\000\000\000\000\000\002=\000\000\000\000\002=\000\000\000\000\002=\000\000\002=\000\000\000\000\t\150\000\000\002=\002=\002=\000\000\002=\002=\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\002=\000\000\002=\000\000\000\000\000\000\000\000\000\000\002=\002=\t\254\n\006\002=\000\000\000\000\000\000\000\000\002=\000\000\002=\002=\000\000\000\000\000\000\000\000\002=\002=\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002=\002=\t\158\t\222\n\022\n\030\002=\002=\002=\000\000\000\000\002=\000\000\002=\002=\000\000\000\000\000\000\000\000\000\000\000\000\002=\002=\002=\000\000\002=\002=\002=\002=\000\000\000\000\000\000\002=\000\000\002=\002=\000\000\002=\002=\002=\n&\002=\002=\000\000\000\000\002=\002=\002=\000\000\000\000\000\000\000\000\002=\002=\002=\002=\002\153\002\153\000\000\000\000\000\000\002\153\000\000\000\000\002\153\000\000\000\000\002\153\000\000\002\153\000\000\000\000\t\150\000\000\002\153\002\153\002\153\000\000\002\153\002\153\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\002\153\000\000\002\153\000\000\000\000\000\000\000\000\000\000\002\153\002\153\t\254\n\006\002\153\000\000\000\000\000\000\000\000\002\153\000\000\002\153\002\153\000\000\000\000\000\000\000\000\002\153\002\153\002\153\000\000\000\000\000\000\000\000\000\000\000\000\002\153\002\153\t\158\t\222\n\022\002\153\002\153\002\153\002\153\000\000\000\000\002\153\000\000\002\153\002\153\000\000\000\000\000\000\000\000\000\000\000\000\002\153\002\153\002\153\000\000\002\153\002\153\002\153\002\153\000\000\000\000\000\000\002\153\000\000\002\153\002\153\000\000\002\153\002\153\002\153\n&\002\153\002\153\000\000\000\000\002\153\002\153\002\153\000\000\000\000\000\000\000\000\002\153\002\153\002\153\002\153\0029\0029\000\000\000\000\000\000\0029\000\000\000\000\0029\000\000\000\000\0029\000\000\0029\000\000\000\000\t\150\000\000\0029\0029\0029\000\000\0029\0029\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\0029\000\000\0029\000\000\000\000\000\000\000\000\000\000\0029\0029\t\254\n\006\0029\000\000\000\000\000\000\000\000\0029\000\000\0029\0029\000\000\000\000\000\000\000\000\0029\0029\000\238\000\000\000\000\000\000\000\000\000\000\000\000\0029\0029\t\158\t\222\n\022\n\030\0029\0029\0029\000\000\000\000\0029\000\000\0029\0029\000\000\000\000\000\000\000\000\000\000\000\000\0029\0029\0029\000\000\0029\0029\0029\0029\000\000\000\000\000\000\0029\000\000\0029\0029\000\000\0029\0029\0029\n&\0029\0029\000\000\000\000\0029\0029\0029\000\000\000\000\000\000\000\000\0029\0029\0029\0029\002q\002q\000\000\000\000\000\000\002q\000\000\000\000\002q\000\000\000\000\002q\000\000\002q\000\000\000\000\t\150\000\000\002q\002q\002q\000\000\002q\002q\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\002q\000\000\002q\000\000\000\000\000\000\000\000\000\000\002q\002q\t\254\n\006\002q\000\000\000\000\000\000\000\000\002q\000\000\002q\002q\000\000\000\000\000\000\000\000\002q\002q\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002q\002q\t\158\t\222\n\022\n\030\002q\002q\002q\000\000\000\000\002q\000\000\002q\002q\000\000\000\000\000\000\000\000\000\000\000\000\002q\002q\002q\000\000\002q\002q\002q\002q\000\000\000\000\000\000\002q\000\000\002q\002q\000\000\002q\002q\002q\n&\002q\002q\000\000\000\000\002q\002q\002q\000\000\000\000\000\000\000\000\002q\002q\002q\002q\002i\002i\000\000\000\000\000\000\002i\000\000\000\000\002i\000\000\000\000\002i\000\000\002i\000\000\000\000\t\150\000\000\002i\002i\002i\000\000\002i\002i\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\002i\000\000\002i\000\000\000\000\000\000\000\000\000\000\002i\002i\t\254\n\006\002i\000\000\000\000\000\000\000\000\002i\000\000\002i\002i\000\000\000\000\000\000\000\000\002i\002i\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002i\002i\t\158\t\222\n\022\n\030\002i\002i\002i\000\000\000\000\002i\000\000\002i\002i\000\000\000\000\000\000\000\000\000\000\000\000\002i\002i\002i\000\000\002i\002i\002i\002i\000\000\000\000\000\000\002i\000\000\002i\002i\000\000\002i\002i\002i\n&\002i\002i\000\000\000\000\002i\002i\002i\000\000\000\000\000\000\000\000\002i\002i\002i\002i\002y\002y\000\000\000\000\000\000\002y\000\000\000\000\002y\000\000\000\000\002y\000\000\002y\000\000\000\000\t\150\000\000\002y\002y\002y\000\000\002y\002y\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002y\000\000\000\000\000\000\000\000\000\000\002y\002y\t\254\n\006\002y\000\000\000\000\000\000\000\000\002y\000\000\n\014\002y\000\000\000\000\000\000\000\000\002y\002y\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002y\002y\t\158\t\222\n\022\n\030\n.\002y\002y\000\000\000\000\002y\000\000\002y\n6\000\000\000\000\000\000\000\000\000\000\000\000\002y\002y\n>\000\000\002y\002y\002y\002y\000\000\000\000\000\000\002y\000\000\002y\002y\000\000\002y\002y\002y\n&\002y\002y\000\000\000\000\002y\nF\002y\000\000\000\000\000\000\000\000\002y\002y\nN\nV\002}\002}\000\000\000\000\000\000\002}\000\000\000\000\002}\000\000\000\000\002}\000\000\002}\000\000\000\000\t\150\000\000\002}\002}\002}\000\000\002}\002}\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\002}\000\000\002}\000\000\000\000\000\000\000\000\000\000\002}\002}\t\254\n\006\002}\000\000\000\000\000\000\000\000\002}\000\000\n\014\002}\000\000\000\000\000\000\000\000\002}\002}\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002}\002}\t\158\t\222\n\022\n\030\n.\002}\002}\000\000\000\000\002}\000\000\002}\n6\000\000\000\000\000\000\000\000\000\000\000\000\002}\002}\n>\000\000\002}\002}\002}\002}\000\000\000\000\000\000\002}\000\000\002}\002}\000\000\002}\002}\002}\n&\002}\002}\000\000\000\000\002}\002}\002}\000\000\000\000\000\000\000\000\002}\002}\nN\nV\002\129\002\129\000\000\000\000\000\000\002\129\000\000\000\000\002\129\000\000\000\000\002\129\000\000\002\129\000\000\000\000\t\150\000\000\002\129\002\129\002\129\000\000\002\129\002\129\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\002\129\000\000\002\129\000\000\000\000\000\000\000\000\000\000\002\129\002\129\t\254\n\006\002\129\000\000\000\000\000\000\000\000\002\129\000\000\n\014\002\129\000\000\000\000\000\000\000\000\002\129\002\129\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\129\002\129\t\158\t\222\n\022\n\030\n.\002\129\002\129\000\000\000\000\002\129\000\000\002\129\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\129\002\129\n>\000\000\002\129\002\129\002\129\002\129\000\000\000\000\000\000\002\129\000\000\002\129\002\129\000\000\002\129\002\129\002\129\n&\002\129\002\129\000\000\000\000\002\129\002\129\002\129\000\000\000\000\000\000\000\000\002\129\002\129\nN\nV\by\by\000\000\000\000\000\000\by\000\000\000\000\by\000\000\000\000\by\000\000\by\000\000\000\000\t\150\000\000\by\by\by\000\000\by\by\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\by\000\000\000\000\000\000\000\000\000\000\by\by\t\254\n\006\by\000\000\000\000\000\000\000\000\by\000\000\n\014\by\000\000\000\000\000\000\000\000\by\by\000\238\000\000\000\000\000\000\000\000\000\000\000\000\by\by\t\158\t\222\n\022\n\030\n.\by\by\000\000\000\000\by\000\000\by\n6\000\000\000\000\000\000\000\000\000\000\000\000\by\by\n>\000\000\by\by\by\by\000\000\000\000\000\000\by\000\000\by\by\000\000\by\by\by\n&\by\by\000\000\000\000\by\nF\by\000\000\000\000\000\000\000\000\by\by\nN\nV\002\133\002\133\000\000\000\000\000\000\002\133\000\000\000\000\002\133\000\000\000\000\002\133\000\000\002\133\000\000\000\000\t\150\000\000\002\133\002\133\002\133\000\000\002\133\002\133\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\133\000\000\000\000\000\000\000\000\000\000\002\133\002\133\t\254\n\006\002\133\000\000\000\000\000\000\000\000\002\133\000\000\n\014\002\133\000\000\000\000\000\000\000\000\002\133\002\133\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\133\002\133\t\158\t\222\n\022\n\030\n.\002\133\002\133\000\000\000\000\002\133\000\000\002\133\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\133\002\133\n>\000\000\002\133\002\133\002\133\002\133\000\000\000\000\000\000\002\133\000\000\002\133\002\133\000\000\n^\002\133\nf\n&\002\133\002\133\000\000\000\000\002\133\nF\002\133\000\000\000\000\000\000\000\000\002\133\002\133\nN\nV\bu\bu\000\000\000\000\000\000\bu\000\000\000\000\bu\000\000\000\000\bu\000\000\bu\000\000\000\000\t\150\000\000\bu\bu\bu\000\000\bu\bu\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\bu\000\000\000\000\000\000\000\000\000\000\bu\bu\t\254\n\006\bu\000\000\000\000\000\000\000\000\bu\000\000\n\014\bu\000\000\000\000\000\000\000\000\bu\bu\000\238\000\000\000\000\000\000\000\000\000\000\000\000\bu\bu\t\158\t\222\n\022\n\030\n.\bu\bu\000\000\000\000\bu\000\000\bu\n6\000\000\000\000\000\000\000\000\000\000\000\000\bu\bu\n>\000\000\bu\bu\bu\bu\000\000\000\000\000\000\bu\000\000\bu\bu\000\000\bu\bu\bu\n&\bu\bu\000\000\000\000\bu\nF\bu\000\000\000\000\000\000\000\000\bu\bu\nN\nV\002\181\002\181\000\000\000\000\000\000\002\181\000\000\000\000\002\181\000\000\000\000\002\181\000\000\002\181\000\000\000\000\t\150\000\000\002\181\002\181\002\181\000\000\002\181\002\181\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\181\000\000\000\000\000\000\000\000\000\000\002\181\002\181\t\254\n\006\002\181\000\000\000\000\000\000\000\000\002\181\000\000\n\014\002\181\000\000\000\000\000\000\000\000\002\181\002\181\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\181\002\181\t\158\t\222\n\022\n\030\n.\002\181\002\181\000\000\000\000\002\181\000\000\002\181\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\181\002\181\n>\000\000\002\181\002\181\002\181\002\181\000\000\000\000\000\000\002\181\000\000\002\181\002\181\000\000\n^\002\181\nf\n&\002\181\002\181\000\000\000\000\002\181\nF\002\181\000\000\000\000\000\000\000\000\002\181\002\181\nN\nV\002\177\002\177\000\000\000\000\000\000\002\177\000\000\000\000\002\177\000\000\000\000\002\177\000\000\002\177\000\000\000\000\t\150\000\000\002\177\002\177\002\177\000\000\002\177\002\177\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\177\000\000\000\000\000\000\000\000\000\000\002\177\002\177\t\254\n\006\002\177\000\000\000\000\000\000\000\000\002\177\000\000\n\014\002\177\000\000\000\000\000\000\000\000\002\177\002\177\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\177\002\177\t\158\t\222\n\022\n\030\n.\002\177\002\177\000\000\000\000\002\177\000\000\002\177\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\177\002\177\n>\000\000\002\177\002\177\002\177\002\177\000\000\000\000\000\000\002\177\000\000\002\177\002\177\000\000\n^\002\177\nf\n&\002\177\002\177\000\000\000\000\002\177\nF\002\177\000\000\000\000\000\000\000\000\002\177\002\177\nN\nV\002\185\002\185\000\000\000\000\000\000\002\185\000\000\000\000\002\185\000\000\000\000\002\185\000\000\002\185\000\000\000\000\t\150\000\000\002\185\002\185\002\185\000\000\002\185\002\185\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\185\000\000\000\000\000\000\000\000\000\000\002\185\002\185\t\254\n\006\002\185\000\000\000\000\000\000\000\000\002\185\000\000\n\014\002\185\000\000\000\000\000\000\000\000\002\185\002\185\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\185\002\185\t\158\t\222\n\022\n\030\n.\002\185\002\185\000\000\000\000\002\185\000\000\002\185\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\185\002\185\n>\000\000\002\185\002\185\002\185\002\185\000\000\000\000\000\000\002\185\000\000\002\185\002\185\000\000\n^\002\185\nf\n&\002\185\002\185\000\000\000\000\002\185\nF\002\185\000\000\000\000\000\000\000\000\002\185\002\185\nN\nV\002\165\002\165\000\000\000\000\000\000\002\165\000\000\000\000\002\165\000\000\000\000\002\165\000\000\002\165\000\000\000\000\t\150\000\000\002\165\002\165\002\165\000\000\002\165\002\165\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\165\000\000\000\000\000\000\000\000\000\000\002\165\002\165\t\254\n\006\002\165\000\000\000\000\000\000\000\000\002\165\000\000\n\014\002\165\000\000\000\000\000\000\000\000\002\165\002\165\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\165\002\165\t\158\t\222\n\022\n\030\n.\002\165\002\165\000\000\000\000\002\165\000\000\002\165\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\165\002\165\n>\000\000\002\165\002\165\002\165\002\165\000\000\000\000\000\000\002\165\000\000\002\165\002\165\000\000\n^\002\165\nf\n&\002\165\002\165\000\000\000\000\002\165\nF\002\165\000\000\000\000\000\000\000\000\002\165\002\165\nN\nV\002\169\002\169\000\000\000\000\000\000\002\169\000\000\000\000\002\169\000\000\000\000\002\169\000\000\002\169\000\000\000\000\t\150\000\000\002\169\002\169\002\169\000\000\002\169\002\169\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\169\000\000\000\000\000\000\000\000\000\000\002\169\002\169\t\254\n\006\002\169\000\000\000\000\000\000\000\000\002\169\000\000\n\014\002\169\000\000\000\000\000\000\000\000\002\169\002\169\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\169\002\169\t\158\t\222\n\022\n\030\n.\002\169\002\169\000\000\000\000\002\169\000\000\002\169\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\169\002\169\n>\000\000\002\169\002\169\002\169\002\169\000\000\000\000\000\000\002\169\000\000\002\169\002\169\000\000\n^\002\169\nf\n&\002\169\002\169\000\000\000\000\002\169\nF\002\169\000\000\000\000\000\000\000\000\002\169\002\169\nN\nV\002\173\002\173\000\000\000\000\000\000\002\173\000\000\000\000\002\173\000\000\000\000\002\173\000\000\002\173\000\000\000\000\t\150\000\000\002\173\002\173\002\173\000\000\002\173\002\173\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\173\000\000\000\000\000\000\000\000\000\000\002\173\002\173\t\254\n\006\002\173\000\000\000\000\000\000\000\000\002\173\000\000\n\014\002\173\000\000\000\000\000\000\000\000\002\173\002\173\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\173\002\173\t\158\t\222\n\022\n\030\n.\002\173\002\173\000\000\000\000\002\173\000\000\002\173\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\173\002\173\n>\000\000\002\173\002\173\002\173\002\173\000\000\000\000\000\000\002\173\000\000\002\173\002\173\000\000\n^\002\173\nf\n&\002\173\002\173\000\000\000\000\002\173\nF\002\173\000\000\000\000\000\000\000\000\002\173\002\173\nN\nV\002\193\002\193\000\000\000\000\000\000\002\193\000\000\000\000\002\193\000\000\000\000\002\193\000\000\002\193\000\000\000\000\t\150\000\000\002\193\002\193\002\193\000\000\002\193\002\193\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\193\000\000\000\000\000\000\000\000\000\000\002\193\002\193\t\254\n\006\002\193\000\000\000\000\000\000\000\000\002\193\000\000\n\014\002\193\000\000\000\000\000\000\000\000\002\193\002\193\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\193\002\193\t\158\t\222\n\022\n\030\n.\002\193\002\193\000\000\000\000\002\193\000\000\002\193\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\193\002\193\n>\000\000\002\193\002\193\002\193\002\193\000\000\000\000\000\000\002\193\000\000\002\193\002\193\000\000\n^\002\193\nf\n&\002\193\002\193\000\000\000\000\002\193\nF\002\193\000\000\000\000\000\000\000\000\002\193\002\193\nN\nV\002\189\002\189\000\000\000\000\000\000\002\189\000\000\000\000\002\189\000\000\000\000\002\189\000\000\002\189\000\000\000\000\t\150\000\000\002\189\002\189\002\189\000\000\002\189\002\189\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\189\000\000\000\000\000\000\000\000\000\000\002\189\002\189\t\254\n\006\002\189\000\000\000\000\000\000\000\000\002\189\000\000\n\014\002\189\000\000\000\000\000\000\000\000\002\189\002\189\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\189\002\189\t\158\t\222\n\022\n\030\n.\002\189\002\189\000\000\000\000\002\189\000\000\002\189\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\189\002\189\n>\000\000\002\189\002\189\002\189\002\189\000\000\000\000\000\000\002\189\000\000\002\189\002\189\000\000\n^\002\189\nf\n&\002\189\002\189\000\000\000\000\002\189\nF\002\189\000\000\000\000\000\000\000\000\002\189\002\189\nN\nV\002\197\002\197\000\000\000\000\000\000\002\197\000\000\000\000\002\197\000\000\000\000\002\197\000\000\002\197\000\000\000\000\t\150\000\000\002\197\002\197\002\197\000\000\002\197\002\197\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\197\000\000\000\000\000\000\000\000\000\000\002\197\002\197\t\254\n\006\002\197\000\000\000\000\000\000\000\000\002\197\000\000\n\014\002\197\000\000\000\000\000\000\000\000\002\197\002\197\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\197\002\197\t\158\t\222\n\022\n\030\n.\002\197\002\197\000\000\000\000\002\197\000\000\002\197\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\197\002\197\n>\000\000\002\197\002\197\002\197\002\197\000\000\000\000\000\000\002\197\000\000\002\197\002\197\000\000\n^\002\197\nf\n&\002\197\002\197\000\000\000\000\002\197\nF\002\197\000\000\000\000\000\000\000\000\002\197\002\197\nN\nV\002\161\002\161\000\000\000\000\000\000\002\161\000\000\000\000\002\161\000\000\000\000\002\161\000\000\002\161\000\000\000\000\t\150\000\000\002\161\002\161\002\161\000\000\002\161\002\161\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\161\000\000\000\000\000\000\000\000\000\000\002\161\002\161\t\254\n\006\002\161\000\000\000\000\000\000\000\000\002\161\000\000\n\014\002\161\000\000\000\000\000\000\000\000\002\161\002\161\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\161\002\161\t\158\t\222\n\022\n\030\n.\002\161\002\161\000\000\000\000\002\161\000\000\002\161\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\161\002\161\n>\000\000\002\161\002\161\002\161\002\161\000\000\000\000\000\000\002\161\000\000\002\161\002\161\000\000\n^\002\161\nf\n&\002\161\002\161\000\000\000\000\002\161\nF\002\161\000\000\000\000\000\000\000\000\002\161\002\161\nN\nV\001\241\001\241\000\000\000\000\000\000\001\241\000\000\000\000\001\241\000\000\000\000\001\241\000\000\001\241\000\000\000\000\001\241\000\000\001\241\001\241\001\241\000\000\001\241\001\241\000\000\000\000\000\000\000\000\001\241\001\241\001\241\001\241\001\241\000\000\001\241\000\000\000\000\000\000\000\000\000\000\001\241\001\241\001\241\001\241\001\241\000\000\000\000\000\000\000\000\001\241\000\000\001\241\001\241\000\000\000\000\000\000\000\000\001\241\001\241\001\241\000\000\000\000\000\000\000\000\000\000\000\000\001\241\001\241\001\241\001\241\001\241\001\241\001\241\001\241\001\241\000\000\000\000\001\241\000\000\001\241\001\241\000\000\000\000\000\000\000\000\000\000\000\000\001\241\001\241\001\241\000\000\001\241\001\241\001\241\001\241\000\000\000\000\000\000\001\241\000\000\001\241\001\241\000\000\001\241\001\241\001\241\001\241\001\241\001\241\000\000\000\000\001\241\001\241\r\202\000\000\000\000\000\000\000\000\001\241\001\241\001\241\001\241\002\r\002\r\000\000\000\000\000\000\002\r\000\000\000\000\002\r\000\000\000\000\002\r\000\000\002\r\000\000\000\000\t\150\000\000\002\r\002\r\002\r\000\000\002\r\002\r\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\r\000\000\000\000\000\000\000\000\000\000\002\r\002\r\t\254\n\006\002\r\000\000\000\000\000\000\000\000\002\r\000\000\n\014\002\r\000\000\000\000\000\000\000\000\002\r\002\r\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\r\t\158\t\222\n\022\n\030\n.\002\r\002\r\000\000\000\000\002\r\000\000\002\r\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\r\n>\000\000\002\r\002\r\r\226\002\r\000\000\000\000\000\000\002\r\000\000\002\r\002\r\000\000\n^\002\r\nf\n&\002\r\002\r\000\000\000\000\002\r\nF\002\r\000\000\000\000\000\000\000\000\002\r\002\r\nN\nV\002\t\002\t\000\000\000\000\000\000\002\t\000\000\000\000\002\t\000\000\000\000\002\t\000\000\002\t\000\000\000\000\t\150\000\000\002\t\002\t\002\t\000\000\002\t\002\t\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\t\000\000\000\000\000\000\000\000\000\000\002\t\002\t\t\254\n\006\002\t\000\000\000\000\000\000\000\000\002\t\000\000\n\014\002\t\000\000\000\000\000\000\000\000\002\t\002\t\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\t\002\t\t\158\t\222\n\022\n\030\n.\002\t\002\t\000\000\000\000\002\t\000\000\002\t\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\t\002\t\n>\000\000\002\t\002\t\002\t\002\t\000\000\000\000\000\000\002\t\000\000\002\t\002\t\000\000\n^\002\t\nf\n&\002\t\002\t\000\000\000\000\002\t\nF\002\t\000\000\000\000\000\000\000\000\002\t\002\t\nN\nV\002\157\002\157\000\000\000\000\000\000\002\157\000\000\000\000\002\157\000\000\000\000\002\157\000\000\002\157\000\000\000\000\t\150\000\000\002\157\002\157\002\157\000\000\002\157\002\157\000\000\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\002\157\000\000\000\000\000\000\000\000\000\000\002\157\002\157\t\254\n\006\002\157\000\000\000\000\000\000\000\000\002\157\000\000\n\014\002\157\000\000\000\000\000\000\000\000\002\157\002\157\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\157\002\157\t\158\t\222\n\022\n\030\n.\002\157\002\157\000\000\000\000\002\157\000\000\002\157\n6\000\000\000\000\000\000\000\000\000\000\000\000\002\157\002\157\n>\000\000\002\157\002\157\002\157\002\157\000\000\000\000\000\000\002\157\000\000\002\157\002\157\000\000\n^\002\157\nf\n&\002\157\002\157\000\000\000\000\002\157\nF\002\157\000\000\000\000\000\000\000\000\002\157\002\157\nN\nV\001\253\001\253\000\000\000\000\000\000\001\253\000\000\000\000\001\253\000\000\000\000\001\253\000\000\001\253\000\000\000\000\001\253\000\000\001\253\001\253\001\253\000\000\001\253\001\253\000\000\000\000\000\000\000\000\001\253\001\253\001\253\001\253\001\253\000\000\001\253\000\000\000\000\000\000\000\000\000\000\001\253\001\253\001\253\001\253\001\253\000\000\000\000\000\000\000\000\001\253\000\000\001\253\001\253\000\000\000\000\000\000\000\000\001\253\001\253\001\253\000\000\000\000\000\000\000\000\000\000\000\000\001\253\001\253\001\253\001\253\001\253\001\253\001\253\001\253\001\253\000\000\000\000\001\253\000\000\001\253\001\253\000\000\000\000\000\000\000\000\000\000\000\000\001\253\001\253\001\253\000\000\001\253\001\253\001\253\001\253\000\000\000\000\000\000\001\253\000\000\001\253\001\253\000\000\001\253\001\253\001\253\001\253\001\253\001\253\000\000\000\000\001\253\001\253\r\202\000\000\000\000\000\000\000\000\001\253\001\253\001\253\001\253\002\001\002\001\000\000\000\000\000\000\002\001\000\000\000\000\002\001\000\000\000\000\002\001\000\000\002\001\000\000\000\000\002\001\000\000\002\001\002\001\002\001\000\000\002\001\002\001\000\000\000\000\000\000\006\177\002\001\002\001\002\001\002\001\002\001\000\000\002\001\000\000\000\000\000\000\000\000\000\000\002\001\002\001\002\001\002\001\002\001\000\000\006\177\003\233\000\000\002\001\006\177\002\001\002\001\000\000\000\000\000\000\000\000\002\001\002\001\002\001\000\000\000\000\000\000\000\000\000\000\000\000\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\000\000\000\000\002\001\000\000\002\001\002\001\000\000\000\000\000\000\000\000\000\000\000\238\002\001\002\001\002\001\000\000\002\001\002\001\002\001\002\001\000\000\000\000\000\000\002\001\000\000\002\001\002\001\000\000\002\001\002\001\002\001\002\001\002\001\002\001\000\000\b\162\002\001\002\001\r\202\000\000\000\000\003\233\000\000\002\001\002\001\002\001\002\001\001\006\000\000\000\006\000\000\000\000\024\214\002\154\002\158\005\254\002\202\002\214\005\194\b\194\000\000\000\000\002\218\001\n\000\000\006\n\000\000\003\018\000\000\006\022\000\000\000\000\000\000\r\182\003\022\001\018\b>\bB\001\030\001\"\000\000\000\000\000\000\003&\000\000\002\226\000\000\025\n\000\000\bf\bj\000\238\003\186\003\014\003\198\bn\006\170\bZ\001:\000\000\002\146\002\002\000\000\003\026\002\002\000\000\000\000\007\234\007\238\007\250\b\014\002\006\005R\000\000\002\006\001>\001B\001F\001J\001N\000\000\000\000\b\130\001R\000\000\000\000\000\000\001V\000\000\b\142\b\166\b\250\005^\005b\003z\005\254\001Z\003z\005\194\024\218\006\214\001\218\001^\006\214\001\218\006\n\000\000\002\146\000\000\006\022\002\146\000\000\001\154\n\222\000\000\000\000\005f\b\002\000\000\001\158\000\000\014\018\004.\t\014\001\006\001\166\000\006\001\170\001\174\000\000\002\154\002\158\000\000\002\202\002\214\006\218\000\000\000\000\006\218\002\218\001\n\000\000\000\000\000\000\b:\000\000\000\000\000\000\000\000\000\000\000\000\003\022\001\018\b>\bB\001\030\001\"\000\000\000\000\000\000\003&\000\000\002\226\000\000\bF\000\000\bf\bj\000\000\003\186\003\014\003\198\bn\006\170\000\000\001:\000\000\002\146\000\000\000\000\003\026\000\000\000\000\000\000\007\234\007\238\007\250\b\014\000\000\005R\000\000\000\000\001>\001B\001F\001J\001N\000\000\000\000\b\130\001R\000\000\000\000\000\000\001V\000\000\b\142\b\166\b\250\005^\005b\000\000\000\000\001Z\000\000\000\000\000\000\000\000\000\000\001^\000\000\000\241\003\170\000\000\002\158\000\000\000\241\000\000\000\000\001\154\005\234\003\138\000\000\005f\b\002\000\000\001\158\007\178\014\018\004.\t\014\n\234\001\166\000\000\001\170\001\174\000\014\000\018\000\022\000\026\000\030\000\000\000\"\000&\000*\000.\0002\000\000\0006\000:\000\000\n\238\000>\003\166\002\158\000\241\000B\0032\000\000\000\000\002\146\000F\000\000\000\241\000\000\000\000\000\000\000J\000\241\000N\000R\000V\000Z\000^\000b\000f\000\000\000\241\000\241\000j\000n\000\000\000r\021\162\000v\000\000\000\000\000\000\006\190\000\000\000\238\000\000\000\000\022\222\002\238\000\000\022\226\000\000\000z\000\000\002\146\000~\000\130\000\241\000\000\000\000\000\000\023\018\000\134\000\138\000\142\000\000\000\241\000\000\000\000\000\000\000\146\000\150\000\154\000\158\000\000\000\162\000\166\000\170\000\000\000\000\000\000\000\174\000\178\000\182\023\"\000\000\000\000\000\186\005\254\000\190\000\194\005\194\n\242\016>\000\000\000\000\000\000\000\198\006\n\000\202\002\002\000\000\006\022\000\000\000\000\000\206\000\210\004Y\000\214\000\006\002\006\000\000\000\246\002\154\002\158\002\162\002\202\002\214\000\000\000\000\000\000\000\000\002\218\000\000\000\000\003\146\000\000\000\000\000\000\004Y\000\000\016N\016\234\003z\002\222\000\000\003\030\003\"\002\002\006\214\001\218\003\150\000\000\003&\000\000\002\226\002\146\016~\002\006\003\178\003\182\000\000\003\186\003\014\003\198\003\206\006\170\000\000\000\000\016\226\002\146\000\000\000\000\003\026\016\250\000\000\000\000\007\234\007\238\007\250\b\014\003z\005R\000\000\006\218\000\000\000\000\006\214\001\218\000\000\017\002\000\000\b\130\000\000\002\146\000\000\000\000\000\000\000\000\b\142\b\166\b\250\005^\005b\017\022\017B\000\000\000\000\004Y\004Y\000\000\000\000\001\202\001\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\218\000\000\017\130\021\134\005f\b\002\024\246\000\141\001\210\b\026\004.\t\014\000\141\000\000\002\158\000\141\000\000\002\214\004E\t6\000\000\000\000\002\218\004E\000\000\000\141\000\000\000\141\000\000\000\141\001\242\002z\t>\000\000\002\222\002~\000\000\002\146\004\006\004\018\tF\000\141\000\000\000\000\004\030\002\226\015r\000\141\000\000\000\000\000\000\000\141\000\000\003\014\001\190\000\000\000\141\000\000\000\000\000\141\002\146\004\"\004E\003\026\000\141\000\141\000\141\007\234\007\238\007\250\004E\0122\005R\000\141\000\141\004E\002\194\000\238\000\000\000\000\000\141\000\000\000\000\000\000\000\141\004E\000\000\000\000\000\000\000\000\000\000\000\000\005^\005b\000\141\000\141\000\000\000\000\000\141\000\141\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\141\002\209\004E\000\000\002\209\000\000\000\141\000\141\005f\b\002\000\000\004E\000\165\b\026\004.\000\000\000\141\000\165\000\141\002\158\000\165\000\000\002\214\000\000\t6\000\n\000\000\002\218\015N\001*\000\165\002b\000\165\000\000\000\165\000\000\002\209\t>\000\000\002\222\002\209\000\000\003:\002\209\000\000\tF\000\165\021.\000\000\000\000\002\226\000\000\000\165\002\209\002\209\003F\000\165\000\000\003\014\001\190\000\n\000\165\000\000\000\000\000\165\002\146\000\000\015R\003\026\000\165\000\165\000\165\007\234\007\238\007\250\002\209\0122\005R\000\165\000\165\002\209\015^\002\209\021R\000\000\000\165\000\000\000\000\002\209\000\165\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\005b\000\165\000\165\000\000\000\000\000\165\000\165\000\000\000\000\015f\001\006\000\000\002\209\000\000\000\000\000\165\0036\002\158\b\226\021^\002\214\000\165\000\165\005f\b\002\002\218\001\n\000\000\b\026\004.\003\018\000\165\000\000\000\165\000\000\016\242\020\242\001\014\001\018\001\022\003V\001\030\001\"\000\000\000\000\003\154\000\000\000\000\000\000\000\000\003Z\000\000\001.\n\218\007\141\000\000\003R\001\190\0016\000\000\000\249\001:\000\000\002\146\000\000\000\249\003\210\025\"\000\000\000\000\003\214\000\000\003\222\005F\002\002\005R\000\000\000\000\001>\001B\001F\001J\001N\000\000\002\006\000\000\001R\005V\000\000\000\000\001V\000\238\000\000\000\000\000\000\005^\005b\000\000\005\162\001Z\000\000\000\000\000\000\000\000\000\249\001^\018\138\003z\000\000\000\000\000\000\000\000\000\249\006\214\001\218\001\154\n\222\000\249\004E\005f\002\146\000\000\001\158\004E\001\162\004.\001\006\000\249\001\166\000\000\001\170\001\174\0036\002\158\n~\005\254\002\214\000\000\005\194\000\000\000\000\002\218\001\n\000\000\000\000\006\n\003\018\000\000\006\218\006\022\000\000\000\000\000\249\001\014\001\018\001\022\003V\001\030\001\"\000\000\000\000\000\249\004E\000\000\000\000\000\000\003Z\000\000\001.\n\218\004E\000\000\003R\001\190\0016\004E\002\194\001:\000\000\002\146\000\000\000\000\003\210\000\000\004E\004E\003\214\000\000\003\222\005F\000\000\005R\000\000\000\000\001>\001B\001F\001J\001N\004q\000\000\000\000\001R\005V\021\174\000\000\001V\000\000\000\000\000\000\004E\005^\005b\000\000\005\162\001Z\000\000\000\000\000\000\004E\000\000\001^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\209\000\000\001\154\n\222\000\000\000\000\005f\002\209\000\000\001\158\000\000\001\162\004.\001\006\022\030\001\166\000\000\001\170\001\174\0036\002\158\rv\016\226\002\214\000\n\000\000\000\000\016\250\002\218\001\n\000\000\000\000\000\000\003\018\000\000\000\000\022\194\022\210\000\000\002\209\001\014\001\018\001\022\003V\001\030\001\"\002\209\000\000\000\000\000\000\000\000\000\000\002\209\003Z\000\000\001.\n\218\000\000\000\000\003R\001\190\0016\004q\000\000\001:\000\000\002\146\000\000\000\000\003\210\000\000\023\198\000\000\003\214\002\209\003\222\005F\000\000\005R\000\000\000\000\001>\001B\001F\001J\001N\000\000\000\000\000\000\001R\005V\000\000\000\000\001V\000\000\000\000\000\000\000\000\005^\005b\000\000\005\162\001Z\000\000\000\000\000\000\000\000\006\178\001^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\154\n\222\000\000\000\000\005f\000\000\000\000\001\158\000\000\001\162\004.\000\000\b\145\001\166\000\006\001\170\001\174\000\246\002\154\002\158\002\162\002\202\002\214\000\000\000\000\000\000\000\000\002\218\000\000\000\000\004y\000\000\b\145\000\000\b\145\b\145\000\000\000\000\000\000\002\222\000\000\003\030\003\"\000\000\000\000\000\000\003\150\000\000\003&\000\000\002\226\000\000\016~\000\000\003\178\003\182\000\000\003\186\003\014\003\198\003\206\006\170\000\000\000\000\016\226\002\146\000\000\000\000\003\026\016\250\001\202\001\206\007\234\007\238\007\250\b\014\000\000\005R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\002\000\000\b\130\001\210\027F\000\000\000\000\000\000\000\000\b\142\b\166\b\250\005^\005b\017\022\017B\000\000\000\000\027k\014\166\000\000\000\000\000\000\000\000\000\000\001\242\002\130\000\000\000\000\000\000\002~\000\000\002\146\004\006\004\018\021\134\005f\b\002\b\145\004\030\000\000\b\026\004.\t\014\000\006\000\000\000\000\000\246\002\154\002\158\002\162\002\202\002\214\000\000\000\000\000\000\004\"\002\218\000\000\026\002\027\154\000\000\000\000\000\000\003\218\000\000\000\000\000\000\000\000\002\222\000\000\003\030\003\"\000\000\000\000\025\238\003\150\000\000\003&\000\000\002\226\000\000\016~\000\000\003\178\003\182\000\000\003\186\003\014\003\198\003\206\006\170\000\000\000\000\016\226\002\146\000\000\000\000\003\026\016\250\000\000\000\000\007\234\007\238\007\250\b\014\000\000\005R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\002\000\000\b\130\000\000\027F\000\000\000\000\000\000\000\000\b\142\b\166\b\250\005^\005b\017\022\017B\000\000\000\000\004\129\000\246\000\000\000\000\002\162\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004y\000\000\000\000\021\134\005f\b\002\014&\0121\0121\b\026\004.\t\014\0121\000\000\0121\0121\003\150\000\000\000\000\000\000\000\000\000\000\016~\0121\000\000\0121\0121\0121\000\000\0121\0121\024F\000\000\000\000\016\226\000\000\000\000\000\000\000\000\016\250\000\000\0121\000\000\000\000\000\000\000\000\000\000\0121\0121\000\000\000\000\0121\000\000\000\000\0121\017\002\0121\000\000\000\000\0121\000\000\000\000\000\000\000\000\0121\0121\0121\000\000\000\000\017\022\017B\000\000\000\000\0121\0121\000\000\000\000\000\000\000\000\000\000\0121\000\000\000\000\000\000\0121\000\000\000\000\0121\000\246\000\000\021\134\002\014\000\000\000\000\0121\0121\0121\000\000\0121\0121\000\000\017\134\000\000\000\000\000\000\000\000\000\000\000\000\0121\000\000\0121\0121\000\000\000\000\002v\0121\000\000\017\138\000\000\000\000\0121\000\000\ne\017\178\0121\ne\0121\0121\ne\ne\000\000\000\000\ne\000\000\ne\016\226\000\000\ne\000\000\000\000\016\250\ne\ne\000\000\ne\ne\000\000\ne\001\202\001\206\000\000\000\000\ne\000\000\000\000\ne\018.\000\000\000\000\000\000\000\000\000\000\000\000\ne\000\000\ne\001\210\000\000\ne\ne\017\022\018B\000\000\000\000\004M\ne\000\000\000\000\ne\000\000\000\000\ne\ne\000\000\ne\000\000\ne\ne\001\242\002\130\000\000\018R\000\000\002~\000\000\002\146\004\006\004\018\000\000\ne\000\000\000\000\004\030\000\000\000\000\000\000\000\000\ne\ne\006\141\000\000\ne\000\000\ne\006\141\000\000\000\000\000\000\005~\004\"\000\000\000\000\004\185\000\000\000\000\ne\ne\000\000\ne\ne\000\000\ne\000\000\ne\000\000\ne\000\000\ne\025\238\ne\b}\b}\000\000\000\000\000\000\b}\000\000\001\206\b}\000\000\000\000\000\000\000\000\006\141\012Q\012=\b}\000\000\b}\b}\b}\006\141\b}\b}\000\000\000\000\006\141\006\141\000\238\000\000\000\000\000\000\012Q\000\000\b}\006\141\006\141\000\000\002\026\000\000\b}\b}\000\000\000\000\b}\002\030\000\000\002z\000\000\b}\000\000\002\"\b}\000\000\002&\012=\000\000\b}\b}\b}\000\000\006\141\000\000\000\000\000\000\000\000\b}\b}\000\000\000\000\006\141\000\000\000\000\b}\000\000\000\000\000\000\004v\000\000\000\000\b}\000\000\000\000\000\000\000\000\000\000\023\166\b}\b}\b}\000\000\b}\b}\000\000\000\000\003\129\012e\000\000\000\000\n\170\000\000\b}\000\000\b}\b}\001\202\001\206\011\n\b}\000\000\000\000\000\000\000\000\b}\003\129\000\000\000\000\b}\003\129\b}\b}\012\r\012\r\002\138\001\226\000\000\012\r\000\000\001\206\012\r\000\000\000\000\001\238\000\000\000\000\000\000\000\000\004\150\000\000\012\r\012\r\012\r\000\000\012\r\012\r\001\242\002r\000\000\000\000\000\000\002~\000\000\002\146\004\006\004\018\012\r\000\000\000\000\000\000\004\030\000\000\012\r\012\r\000\000\000\000\012\r\000\000\000\000\002z\000\000\012\r\012e\012e\012\r\000\000\000\000\004\"\000\000\012\r\012\r\012\r\000\000\000\000\000\000\003\129\000\000\000\000\012\r\012\r\000\000\012e\000\000\012e\000\000\012\r\000\000\000\000\000\000\004v\003\129\000\000\012\r\003\129\000\000\000\000\000\000\000\000\000\000\012\r\012\r\012\r\000\000\012\r\012\r\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\r\000\000\012\r\012\r\001\202\001\206\000\000\012\r\000\000\000\000\000\000\000\000\012\r\000\000\000\000\000\000\012\r\000\000\012\r\012\r\b\129\b\129\001\210\001\226\002\209\b\129\000\000\001\206\b\129\002\209\000\000\001\238\000\000\000\000\018\130\000\000\b\129\000\000\b\129\b\129\b\129\000\000\b\129\b\129\001\242\019\250\000\000\019\014\000\000\002~\000\000\002\146\004\006\004\018\b\129\000\n\000\000\000\000\020\n\000\000\b\129\b\129\000\000\000\000\b\129\000\000\000\000\002z\002\209\b\129\002\209\000\000\b\129\000\000\000\000\004\"\002\209\b\129\b\129\b\129\000\000\002\209\000\000\002\209\000\000\000\000\b\129\b\129\000\000\000\000\002\209\002\209\000\000\b\129\002\209\002\209\002\209\004v\002\209\000\000\b\129\000\000\000\000\002\209\000\000\000\000\002\209\b\129\b\129\b\129\000\000\b\129\b\129\000\000\000\000\002\209\002\209\000\000\002\209\000\n\000\n\b\129\002\209\b\129\b\129\002\209\002\209\002\209\b\129\002\209\002\209\002\209\002\209\b\129\002\209\002\209\002\209\b\129\000\000\b\129\b\129\002\209\002\209\000\000\002\209\002\209\000\000\002\209\002\209\002\209\002\209\000\n\000\000\002\209\006\174\000\000\002\209\002\209\002\209\000\000\015\006\000\000\002\209\002\209\000\000\002\209\002\209\002\209\002\209\002\209\002\209\000\000\000\000\002\209\002\209\000\000\002\209\000\000\000\000\002\209\002\209\002\209\002\209\002\209\002\209\002\209\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\209\000\000\002\209\002\209\000\000\000\000\000\000\002\209\002\209\002\209\002\209\002\209\000\000\015B\000\000\000\000\006=\002\209\000!\000\000\000\000\000\000\000!\000!\000\000\000!\000!\000\000\000\000\015N\000\000\000!\002b\000\000\002\209\002\209\006=\000\000\000\000\002\209\002\209\002\209\000\000\000!\000\000\000!\000!\000\000\000\000\000\000\000\000\000\000\000!\000\000\000!\000\000\000\000\000\000\000!\000!\000\000\000!\000!\000!\000!\000!\000\000\000\000\015R\000!\007\025\000\000\000!\007\025\000\000\000\000\000!\000!\000!\000!\000\000\000!\015^\000\000\0212\000\000\000\000\000\000\000\000\007\025\007\025\000!\007\025\007\025\000\000\000\000\000\000\000\000\000!\000!\000!\000!\000!\000\000\000\000\000\000\000\000\0069\015f\000\029\000\000\007\025\000\000\000\029\000\029\000\000\000\029\000\029\021>\000\000\000\000\000\000\000\029\000\000\000\000\000!\000!\0069\000\000\007\025\000!\000!\000!\000\000\000\029\020\242\000\029\000\029\000\000\000\000\000\000\000\000\000\000\000\029\000\000\000\029\000\000\000\000\000\000\000\029\000\029\000\000\000\029\000\029\000\029\000\029\000\029\000\000\000\000\007\025\000\029\007\025\000\000\000\029\000\000\000\000\000\000\000\029\000\029\000\029\000\029\000\000\000\029\005\186\000\000\000\000\007\025\007\025\000\000\000\000\000\000\007\025\000\029\007\025\000\000\000\000\000\000\007\025\000\000\000\029\000\029\000\029\000\029\000\029\000\000\000\000\000\000\000\000\006I\000\000\011\213\000\000\000\000\000\000\011\213\011\213\000\000\011\213\011\213\000\000\000\000\000\000\000\000\011\213\000\000\000\000\000\029\000\029\006I\000\000\000\000\000\029\000\029\000\029\000\000\011\213\000\000\011\213\011\213\000\000\000\000\000\000\000\000\000\000\011\213\000\000\011\213\000\000\000\000\000\000\011\213\011\213\000\000\011\213\011\213\011\213\011\213\011\213\000\000\000\000\000\000\011\213\007-\000\000\011\213\007-\000\000\000\000\011\213\011\213\011\213\011\213\000\000\011\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007-\007-\011\213\007-\007-\000\000\000\000\000\000\000\000\011\213\011\213\011\213\011\213\011\213\000\000\000\000\000\000\000\000\006E\000\000\011\209\000\000\007-\000\000\011\209\011\209\000\000\011\209\011\209\000\000\000\000\000\000\000\000\011\209\000\000\000\000\011\213\011\213\006E\000\000\000\238\011\213\011\213\011\213\000\000\011\209\000\000\011\209\011\209\000\000\000\000\000\000\000\000\000\000\011\209\000\000\011\209\000\000\000\000\000\000\011\209\011\209\000\000\011\209\011\209\011\209\011\209\011\209\000\000\000\000\007-\011\209\007-\000\000\011\209\000\000\000\000\000\000\011\209\011\209\011\209\011\209\000\000\011\209\007-\000\000\000\000\005\194\007-\000\000\000\000\000\000\007-\011\209\007-\000\000\000\000\000\000\007-\000\000\011\209\011\209\011\209\011\209\011\209\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004M\000\000\000\000\000\000\000\000\000\246\000\000\000\000\002\014\012\017\012\017\000\000\000\000\000\000\012\017\011\209\011\209\012\017\017\134\000\000\011\209\011\209\011\209\012Q\012=\004F\000\000\012\017\012\017\012\017\000\000\012\017\012\017\000\000\017\138\000\000\000\000\000\000\000\000\000\000\017\178\012Q\000\000\012\017\000\000\000\000\000\000\002\026\000\000\012\017\012\017\000\000\016\226\012\017\002\174\000\000\000\000\016\250\012\017\000\000\002\"\012\017\000\000\002&\012=\000\000\012\017\012\017\012\017\000\000\000\000\000\000\000\000\018.\000\000\012\017\012\017\000\000\000\000\000\000\000\000\000\000\012\017\000\000\000\000\000\000\012\017\017\022\018B\012\017\000\000\000\000\004M\000\000\000\000\000\000\012\017\012\017\012\017\000\000\012\017\012\017\000\000\000\000\000\000\000\000\000\000\000\000\018R\007\153\012\017\000\006\012\017\012\017\007\153\002\154\002\158\012\017\002\202\002\214\000\000\000\000\012\017\000\000\002\218\000\000\012\017\000\000\012\017\012\017\000\000\014:\000\000\000\000\000\000\000\000\002\222\000\000\003\030\003\"\000\000\000\000\000\000\000\000\000\000\003&\000\000\002\226\000\000\000\000\000\000\003\178\003\182\007\153\003\186\003\014\003\198\003\206\006\170\000\000\000\000\007\153\002\146\000\000\000\000\003\026\007\153\007\153\000\238\007\234\007\238\007\250\b\014\000\000\005R\007\153\007\153\001\181\000\000\000\000\000\000\000\000\001\181\000\000\b\130\000\000\000\000\000\000\000\000\000\000\000\000\b\142\b\166\b\250\005^\005b\000\000\000\000\007\153\000\000\000\000\007\153\000\000\000\000\000\000\000\000\000\000\000\000\003\t\003\t\007\153\000\000\000\000\003\t\000\000\000\000\003\t\000\000\005f\b\002\000\000\001\181\000\000\b\026\004.\t\014\003\t\003\t\003\t\001\181\003\t\003\t\000\000\000\000\001\181\001\181\000\238\000\000\000\000\000\000\000\000\000\000\003\t\001\181\001\181\000\000\000\000\000\000\003\t\004>\000\000\000\000\003\t\000\000\000\000\000\000\000\000\003\t\000\000\000\000\003\t\000\000\000\000\000\000\000\000\003\t\003\t\003\t\000\000\001\181\000\000\000\000\000\000\000\000\003\t\003\t\000\000\000\000\001\181\000\000\000\000\003\t\000\000\nq\000\000\003\t\nq\000\000\003\t\0036\002\158\000\000\000\000\002\214\000\000\003\t\003\t\003\t\002\218\003\t\003\t\000\000\nq\nq\000\000\nq\nq\000\000\000\000\003\t\000\000\003\t\003\t\003:\000\000\000\000\003\t\000\000\000\000\000\000\000\000\003\t\000\000\000\000\nq\003\t\003F\003\t\003\t\003R\001\190\003\133\012e\000\000\000\000\000\000\002\146\000\000\000\000\003\210\000\000\000\000\nq\003\214\000\000\003\222\005F\000\000\005R\000\000\003\133\000\000\000\000\000\000\003\133\000\000\000\000\000\000\000\000\000\000\005V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\005b\000\000\005\162\nq\000\000\nq\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\nq\000\000\000\000\nq\nq\000\000\005f\000\000\nq\000\000\nq\000\000\004.\nm\nq\000\000\nm\000\000\000\000\0036\002\158\012e\012e\002\214\000\000\006z\000\000\000\000\002\218\000\000\000\000\000\000\nm\nm\003\133\nm\nm\000\000\006\154\000\000\012e\000\000\012e\003:\000\000\000\000\b\178\000\000\000\000\003\133\000\000\000\000\003\133\000\000\nm\000\000\003F\000\000\000\000\003R\001\190\000\000\000\000\000\000\000\000\000\000\002\146\000\000\000\000\003\210\000\000\000\000\nm\003\214\000\000\003\222\005F\n\138\005R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004i\005V\000\000\000\000\000\000\018\154\001\205\001\205\000\000\005^\005b\001\205\005\162\nm\001\205\nm\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\205\001\205\001\205\nm\001\205\001\205\nm\nm\000\000\005f\000\000\nm\000\000\nm\000\000\004.\001\205\nm\000\000\000\000\018\198\000\000\001\205\001\205\000\000\000\000\001\205\000\000\016\226\000\000\000\000\001\205\000\000\016\250\001\205\000\000\000\000\000\000\000\000\001\205\001\205\001\205\000\000\019\002\000\000\000\000\000\000\000\000\001\205\001\205\000\000\000\000\000\000\000\000\000\000\001\205\000\000\0036\002\158\001\205\000\000\002\214\001\205\006z\000\000\000\000\002\218\000\000\004i\001\205\001\205\001\205\000\000\001\205\001\205\000\000\006\154\019v\000\000\000\000\000\000\003:\000\000\001\205\b\178\001\205\001\205\000\000\000\000\000\000\001\205\000\000\000\000\000\000\003F\001\205\000\000\nz\001\190\004\218\000\000\001\205\000\000\000\000\002\146\000\000\000\000\003\210\000\000\000\000\nI\003\214\000\000\003\222\000\000\n\138\005R\000\000\000\000\012\129\000\000\000\000\000\000\000\000\012\129\000\000\000\000\000\000\005V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\005b\000\000\000\000\n\146\000\000\000\000\0036\002\158\000\000\000\000\002\214\000\000\006z\000\000\000\000\002\218\000\000\nI\n\154\000\000\nI\011\006\000\000\005f\000\000\006\154\012\129\nI\000\000\004.\003:\nI\000\000\b\178\012\129\007\005\000\000\000\000\007\005\012\129\012\129\000\238\000\000\003F\000\000\000\000\nz\001\190\012\129\012\129\000\000\000\000\000\000\002\146\007\005\007\005\003\210\007\005\007\005\nI\003\214\000\000\003\222\000\000\n\138\005R\000\000\000\000\000\000\000\000\005)\005)\000\000\000\000\012\129\005)\007\005\005V\005)\000\000\000\000\000\000\000\000\012\129\000\000\005^\005b\000\000\005)\n\146\005)\000\000\005)\000\000\007\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\nI\005)\000\000\nI\nI\000\000\005f\005)\005)\000\000\nI\000\000\004.\005)\nI\000\000\005)\000\000\000\000\005)\000\000\007\005\000\000\007\005\005)\005)\005)\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\005\000\000\000\000\005\194\007\005\005)\005)\000\000\007\005\005)\007\005\000\000\000\000\000\000\007\005\b\141\000\000\000\000\000\000\005)\005)\005)\000\000\005)\005)\000\000\000\000\000\000\000\000\007B\000\000\t\150\000\000\000\000\012\006\b\141\005)\b\141\b\141\005)\005)\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\000\000\000\000\005)\001\202\002^\000\000\000\000\002b\t\254\n\006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\014\000\000\000\000\000\000\001\210\001\226\002f\000\000\000\238\000\000\000\000\000\000\000\000\001\238\000\000\000\000\001\006\t\158\t\222\n\022\n\030\n.\000\000\000\000\000\000\000\000\002j\002r\000\000\n6\000\000\002~\001\n\002\146\004\006\004\018\000\000\000\000\n>\000\000\020\222\000\000\020\226\001\014\001\018\001\022\001\026\001\030\001\"\000\000\000\000\000\000\n^\000\000\nf\n&\001&\004\"\001.\0012\b\141\nF\000\000\000\000\0016\000\000\015f\001:\000\000\nN\nV\000\000\000\000\000\000\000\000\000\000\020\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001>\001B\001F\001J\001N\000\000\000\000\000\000\001R\020\242\000\000\000\000\001V\000\000\005\029\005\029\000\000\000\000\000\000\005\029\000\000\001Z\005\029\000\000\000\000\000\000\000\000\001^\000\000\000\000\000\000\000\000\005\029\000\000\005\029\000\000\005\029\001\154\000\000\000\000\000\000\000\000\000\000\000\000\001\158\000\000\001\162\000\000\005\029\000\000\001\166\000\000\001\170\001\174\005\029\005\029\000\000\000\000\000\000\000\000\007\174\000\000\000\000\005\029\000\000\000\000\005\029\000\000\000\000\000\000\000\000\005\029\005\029\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\029\005\029\003I\003I\005\029\000\000\000\000\003I\000\000\000\000\003I\000\000\000\000\000\000\005\029\005\029\005\029\000\000\005\029\005\029\003I\000\000\003I\000\000\003I\000\000\000\000\000\000\000\000\000\000\000\000\005\029\000\000\000\000\005\029\005\029\003I\000\000\000\000\000\000\000\000\000\000\003I\003I\000\000\000\000\005\029\000\000\004\233\000\000\000\000\003I\000\000\000\000\003I\000\000\000\000\000\000\000\000\003I\003I\003I\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003I\000\000\000\000\000\000\003I\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003I\003I\003I\000\000\003I\003I\b\t\b\t\000\000\000\000\004\233\b\t\000\000\000\000\b\t\000\000\000\000\003I\000\000\000\000\000\000\003I\000\000\000\000\b\t\000\000\b\t\000\000\b\t\000\000\000\000\000\000\003I\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\t\000\000\000\000\000\000\000\000\000\000\b\t\b\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\t\000\000\000\000\b\t\000\000\000\000\000\000\000\000\b\t\b\t\b\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\t\000\000\012\193\012\193\b\t\000\000\000\000\012\193\000\000\000\000\012\193\000\000\000\000\000\000\b\t\b\t\b\t\000\000\b\t\b\t\012\193\000\000\012\193\000\000\012\193\000\000\000\000\000\000\b\t\000\000\000\000\b\t\000\000\000\000\000\000\b\t\012\193\000\000\000\000\000\000\000\000\000\000\012\193\012\193\004\218\000\000\b\t\000\000\004N\000\000\000\000\012\193\000\000\000\000\012\193\000\000\000\000\000\000\000\000\012\193\012\193\012\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\193\000\000\000\000\000\000\012\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\193\012\193\012\193\000\000\012\193\012\193\012\197\012\197\000\000\000\000\004^\012\197\000\000\000\000\012\197\000\000\000\000\012\193\000\000\000\000\000\000\012\193\000\000\000\000\012\197\000\000\012\197\000\000\012\197\000\000\000\000\000\000\012\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\197\000\000\000\000\000\000\000\000\000\000\012\197\012\197\000\000\000\000\000\000\000\000\004N\000\000\000\000\012\197\000\000\000\000\012\197\000\000\000\000\000\000\000\000\012\197\012\197\012\197\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\197\000\000\000\000\000\000\012\197\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\197\012\197\012\197\000\000\012\197\012\197\003I\003I\000\000\000\000\004^\003I\000\000\000\000\003I\000\000\000\000\012\197\000\000\000\000\000\000\012\197\000\000\000\000\003I\000\000\003I\000\000\003I\000\000\000\000\000\000\012\197\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003I\000\000\000\000\000\000\000\000\000\000\003I\003I\000\000\000\000\000\000\000\000\004\237\000\000\000\000\003I\000\000\000\000\003I\000\000\000\000\000\000\000\000\003I\003I\003I\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003I\000\000\000\000\000\000\003I\007\149\000\000\000\000\000\000\006\161\007\149\000\000\000\000\000\000\003I\003I\003I\000\000\003I\003I\000\000\000\000\000\000\000\000\004\237\t\150\000\000\000\000\006\161\000\000\000\000\003I\006\161\000\000\000\000\003I\000\000\t\206\t\230\t\238\t\214\t\246\000\000\000\000\000\000\000\000\003I\000\000\000\000\007\149\000\000\t\254\n\006\000\000\000\000\000\000\000\000\007\149\000\000\000\000\n\014\000\000\007\149\007\149\000\238\000\000\000\000\000\000\000\238\000\000\000\000\007\149\007\149\000\000\000\000\000\000\000\000\t\158\t\222\n\022\n\030\n.\000\000\000\000\000\000\001\189\000\000\000\000\006\161\n6\001\189\000\000\001\206\001\189\007\149\000\000\000\000\007\149\n>\000\000\000\000\bi\000\000\001\189\000\000\000\000\007\149\001\189\000\000\000\000\000\000\000\000\n^\000\000\nf\n&\000\000\000\000\000\000\001\189\000\000\nF\000\000\012)\000\000\001\189\001\189\000\000\012)\nN\nV\012)\002z\000\000\001\189\000\000\000\000\001\189\000\000\000\000\000\000\012)\001\189\001\189\001\189\012)\000\000\000\000\003-\000\000\000\000\0121\000\000\003-\000\000\001\206\003-\012)\001\189\001\189\000\000\000\000\004v\012)\be\000\000\003-\000\000\000\000\000\000\003-\000\000\001\189\001\189\000\000\012)\001\189\001\189\000\000\000\000\012)\012)\003-\000\000\000\000\000\000\001\189\000\000\003-\001\185\000\000\000\000\000\000\001\189\000\000\002z\012)\003-\001\189\000\000\003-\000\000\000\000\000\000\001\189\003-\003-\003-\000\000\000\000\012)\012)\002Z\000\000\012)\012)\000\000\000\000\000\000\000\000\000\000\003-\003-\000\000\012)\004v\000\000\000\000\026b\000\000\000\000\012)\000\000\000\000\0162\003-\003-\000\000\000\000\003-\003-\000\000\012)\000\000\000\000\000\000\000\000\000\000\000\000\003-\t\150\000\000\000\000\000\000\0166\000\000\003-\000\000\000\000\000\000\000\000\003-\t\206\t\230\t\238\t\214\t\246\003-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\254\n\006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\014\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\158\t\222\n\022\n\030\n.\000\000\000\149\000\000\000\000\000\000\000\000\000\149\n6\000\000\000\149\000\000\000\000\000\000\000\000\000\000\000\000\n>\000\000\000\000\000\149\000\000\000\149\000\000\000\149\000\000\000\000\000\000\000\000\000\000\000\000\n^\016:\nf\n&\016J\000\149\000\000\000\000\000\000\nF\000\000\000\149\000\000\000\000\000\000\000\149\000\000\nN\nV\000\000\000\149\000\000\000\000\000\149\000\000\000\000\000\000\000\000\000\149\000\149\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\149\000\149\000\000\000\000\000\000\000\000\000\000\000\149\000\000\000\000\000\217\000\149\000\000\000\000\000\000\000\217\000\000\000\000\000\217\000\000\000\000\000\149\000\149\000\000\000\000\000\149\000\149\000\000\000\217\000\000\000\217\000\000\000\217\000\000\000\000\000\149\000\000\000\000\000\000\000\000\000\000\000\149\000\149\000\000\000\217\000\000\000\000\000\000\000\000\000\000\000\217\000\149\000\000\000\149\000\217\000\000\000\000\000\000\000\000\000\217\000\000\000\000\000\217\000\000\000\000\000\000\000\000\000\217\000\217\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\217\000\217\000\000\000\000\000\000\000\000\000\000\000\217\000\000\000\000\000\157\000\217\000\000\000\000\000\000\000\157\000\000\000\000\000\157\000\000\000\000\000\217\000\217\000\000\000\000\000\217\000\217\000\000\000\157\000\000\000\157\000\000\000\157\000\000\000\000\000\217\000\000\000\000\000\000\000\000\000\000\000\217\000\217\000\000\000\157\000\000\000\000\000\000\000\000\000\000\000\157\000\217\000\000\000\217\000\157\000\000\000\000\000\000\000\000\000\157\000\000\000\000\000\157\000\000\000\000\000\000\000\000\000\157\000\157\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\157\000\157\000\000\000\000\000\000\000\000\000\000\000\157\000\000\000\000\000\153\000\157\000\000\000\000\000\000\000\153\000\000\000\000\000\153\000\000\000\000\000\157\000\157\000\000\000\000\000\157\000\157\000\000\000\153\000\000\000\153\000\000\000\153\000\000\000\000\000\157\000\000\000\000\000\000\000\000\000\000\000\157\000\157\000\000\000\153\006}\006}\000\000\000\000\000\000\000\153\000\157\000\000\000\157\000\153\000\000\000\000\000\000\000\000\000\153\000\000\004\022\000\153\006}\006}\000\000\000\000\000\153\000\153\000\238\000\000\000\000\006}\001\129\000\000\000\000\000\153\000\153\001\129\000\000\000\000\001\129\000\000\000\153\000\000\006}\006}\000\153\000\000\000\000\006}\001\129\006}\006}\006}\001\129\000\000\000\153\000\153\006}\000\000\000\153\000\153\000\000\000\000\000\000\000\000\001\129\001\129\000\000\000\000\000\153\000\000\001\129\000\000\000\000\006}\000\153\000\153\004\233\000\000\000\000\001\129\000\000\000\000\001\129\000\000\000\153\000\000\000\153\001\129\001\129\001\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\129\000\000\000\000\000\000\001\129\000\000\004\n\000\000\006}\000\000\000\000\000\000\000\000\000\000\001\129\001\129\000\000\000\000\001\129\001\129\000\000\012\189\012\189\000\000\004\233\000\000\012\189\000\000\001\129\012\189\000\000\000\000\000\000\000\000\001\129\001\129\000\000\000\000\000\000\012\189\001\129\012\189\000\000\012\189\000\000\000\000\001\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\189\000\000\000\000\000\000\000\000\000\000\012\189\012\189\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\189\000\000\000\000\012\189\000\000\000\000\000\000\000\000\012\189\012\189\012\189\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\189\000\000\012\185\012\185\012\189\000\000\000\000\012\185\000\000\000\000\012\185\000\000\000\000\000\000\012\189\012\189\012\189\000\000\012\189\012\189\012\185\000\000\012\185\000\000\012\185\000\000\000\000\000\000\000\000\000\000\000\000\012\189\000\000\000\000\000\000\012\189\012\185\000\000\000\000\000\000\000\000\000\000\012\185\012\185\004\218\000\000\012\189\000\000\000\000\000\000\000\000\012\185\000\000\000\000\012\185\000\000\000\000\000\000\000\000\012\185\012\185\012\185\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\185\000\000\b\r\b\r\012\185\000\000\000\000\b\r\000\000\000\000\b\r\000\000\000\000\000\000\012\185\012\185\012\185\000\000\012\185\012\185\b\r\000\000\b\r\000\000\b\r\000\000\000\000\000\000\007\030\000\000\000\000\012\185\000\000\000\000\000\000\012\185\b\r\000\000\000\000\000\000\000\000\000\000\b\r\b\r\000\000\000\000\012\185\000\000\000\000\000\000\000\000\b\r\000\000\000\000\b\r\000\000\000\000\000\000\000\000\b\r\b\r\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\134\000\000\n\158\000\000\000\000\000\000\b\r\000\000\001\202\001\206\b\r\000\000\000\000\000\000\000\000\000\000\t\150\000\000\000\000\012\006\b\r\b\r\b\r\b\141\b\r\b\r\001\210\001\226\t\206\t\230\t\238\t\214\t\246\000\000\b\r\001\238\000\000\b\r\000\000\000\000\000\000\b\r\t\254\n\006\000\000\000\000\000\000\000\000\001\242\002r\000\000\n\014\b\r\002~\000\000\002\146\004\006\004\018\000\000\000\238\000\000\000\000\004\030\000\000\000\000\000\000\000\000\000\000\t\158\t\222\n\022\n\030\n.\000\000\000\000\000\000\001\185\000\000\000\000\004\"\n6\001\185\000\000\001\206\001\185\000\000\000\000\000\000\000\000\n>\000\000\000\000\be\000\000\001\185\000\000\000\000\000\000\001\185\000\000\000\000\000\000\000\000\n^\000\000\nf\n&\000\000\000\000\000\000\001\185\000\000\nF\000\000\000\000\004*\001\185\004.\000\000\000\000\nN\nV\000\000\002z\000\000\001\185\000\000\000\000\001\185\000\000\000\000\000\000\000\000\001\185\001\185\001\185\000\000\000\000\000\000\001i\000\000\000\000\000\000\000\000\001i\000\000\0121\001i\000\000\001\185\001\185\000\000\000\000\004v\000\000\0121\000\000\001i\000\000\001i\000\000\001i\000\000\001\185\001\185\000\000\000\000\001\185\001\185\000\000\000\000\000\000\000\000\001i\000\000\000\000\000\000\001\185\000\000\001i\0121\000\000\000\000\000\000\001\185\000\000\0121\000\000\000\000\001\185\000\000\001i\000\000\000\000\000\000\001\185\001i\001i\001i\000\000\000\000\000\000\005U\005U\000\000\000\000\000\000\005U\000\000\000\000\005U\000\000\001i\000\000\000\000\000\000\0121\000\000\000\000\000\000\005U\000\000\005U\000\000\005U\000\000\001i\001i\001i\000\000\001i\001i\000\000\000\000\000\000\000\000\005U\000\000\000\000\000\000\000\000\000\000\005U\005U\000\000\000\000\019\254\001i\007\174\000\000\000\000\005U\000\000\000\000\005U\000\000\000\000\000\000\001i\005U\005U\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005U\000\000\005Q\006\242\005U\000\000\000\000\005Q\000\000\000\000\005Q\000\000\000\000\000\000\005U\005U\005U\000\000\005U\005U\005Q\000\000\005Q\000\000\005Q\000\000\000\000\000\000\000\000\000\000\000\000\005U\000\000\000\000\000\000\005U\005Q\000\000\000\000\000\000\000\000\000\000\005Q\007^\000\000\000\000\005U\000\000\000\000\000\000\000\000\005Q\000\000\000\000\005Q\000\000\000\000\000\000\000\000\005Q\005Q\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005Q\000\000\005m\005m\005Q\000\000\000\000\005m\000\000\000\000\005m\000\000\000\000\000\000\005Q\005Q\005Q\000\000\005Q\005Q\005m\000\000\005m\000\000\005m\000\000\000\000\000\000\000\000\000\000\000\000\005Q\000\000\000\000\000\000\005Q\005m\000\000\000\000\000\000\000\000\000\000\005m\005m\000\000\000\000\005Q\000\000\000\000\000\000\000\000\005m\000\000\000\000\005m\000\000\000\000\000\000\000\000\005m\005m\005m\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005m\000\000\005i\006\242\005m\000\000\000\000\005i\000\000\000\000\005i\000\000\000\000\000\000\005m\005m\005m\000\000\005m\005m\005i\000\000\005i\000\000\005i\000\000\000\000\000\000\000\000\000\000\000\000\005m\000\000\000\000\000\000\005m\005i\000\000\000\000\000\000\000\000\000\000\005i\007^\000\000\000\000\007V\000\000\000\000\000\000\000\000\005i\000\000\000\000\005i\000\000\000\000\000\000\000\000\005i\005i\000\238\004E\000\000\000\000\000\000\000\000\004E\0036\002\158\004E\000\000\002\214\000\000\006z\005i\000\000\002\218\000\000\005i\004E\000\000\000\000\000\000\004E\000\000\000\000\006\154\000\000\005i\005i\005i\003:\005i\005i\b\178\004E\000\000\000\000\000\000\000\000\000\000\004E\000\000\000\000\003F\005i\000\000\nz\001\190\005i\004E\000\000\011\226\004E\002\146\000\000\000\000\003\210\004E\002\194\005i\003\214\000\000\003\222\000\000\n\138\005R\000\000\t\150\000\000\000\000\000\000\000\000\000\000\004E\011\230\000\000\000\000\005V\000\000\t\206\t\230\t\238\t\214\t\246\000\000\005^\005b\004E\004E\n\146\000\000\004E\004E\t\254\n\006\000\000\000\000\007B\000\000\000\000\000\000\000\000\n\014\000\000\n\154\000\000\000\000\n\166\004E\005f\000\238\000\000\000\000\021\006\000\000\004.\011\226\000\000\000\000\t\158\t\222\n\022\n\030\n.\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n6\t\150\000\000\000\000\000\000\000\000\000\000\000\000\012\190\n>\000\000\000\000\000\000\t\206\t\230\t\238\t\214\t\246\000\000\000\000\000\000\000\000\000\000\n^\000\000\nf\n&\t\254\n\006\000\000\000\000\000\000\nF\000\000\000\000\000\000\n\014\000\000\000\000\000\000\nN\nV\000\000\000\000\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\158\t\222\n\022\n\030\n.\000\000\000\000\000\000\003)\000\000\000\000\000\000\n6\003)\000\000\001\206\003)\000\000\000\000\000\000\000\000\n>\000\000\000\000\000\000\000\000\003)\000\000\000\000\000\000\003)\000\000\000\000\000\000\000\000\n^\000\000\nf\n&\000\000\000\000\000\000\003)\000\000\nF\000\000\000\000\000\000\003)\000\000\000\000\000\000\nN\nV\000\000\002z\000\000\003)\000\000\000\000\003)\000\000\000\000\000\000\000\000\003)\003)\003)\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003)\003)\000\000\000\000\004v\n\170\000\000\000\000\000\000\000\000\000\246\001\202\001\206\002\014\003)\003)\000\000\000\000\003)\003)\000\000\000\000\000\000\017\134\000\000\000\000\000\000\004M\003)\001\210\001\226\000\000\000\000\000\000\000\000\003)\000\000\000\000\001\238\017\138\003)\000\000\000\000\000\000\000\000\017\178\003)\000\000\000\000\000\000\0071\001\242\002r\0071\000\000\000\000\002~\016\226\002\146\004\006\004\018\000\000\016\250\0011\000\000\004\030\000\000\000\000\0011\0071\0071\0011\0071\0071\000\000\000\000\000\000\000\000\018.\000\000\000\000\0011\004\"\0011\000\000\0011\000\000\000\000\000\000\000\000\000\000\0071\017\022\018B\000\000\000\000\000\000\0011\000\000\000\000\000\000\000\000\000\000\0011\000\000\000\000\000\000\0011\000\000\000\238\000\000\000\000\0011\018R\000\000\0011\000\000\000\000\000\000\000\000\0011\0011\000\238\000\000\000\000\000\000\001-\000\000\000\000\000\000\0011\001-\000\000\000\000\001-\000\000\0011\000\000\000\000\0071\0011\0071\000\000\000\000\001-\000\000\001-\000\000\001-\000\000\0011\0011\0011\0071\0011\0011\005\194\0071\000\000\000\000\001-\0071\000\000\0071\0011\000\000\001-\0071\000\000\000\000\001-\0011\000\000\000\000\000\000\001-\000\000\000\000\001-\000\000\000\000\000\000\0011\001-\001-\000\238\000\000\000\000\000\000\001m\000\000\000\000\000\000\001-\001m\000\000\0125\001m\000\000\001-\000\000\000\000\000\000\001-\000\000\0125\000\000\001m\000\000\001m\000\000\001m\000\000\001-\001-\001-\000\000\001-\001-\000\000\000\000\000\000\000\000\001m\000\000\000\000\000\000\001-\000\000\001m\0125\000\000\000\000\000\000\001-\000\000\0125\000\000\000\000\000\000\000\000\001m\000\000\000\000\000\000\001-\001m\001m\001m\000\000\000\000\000\000\001\029\000\000\000\000\000\000\000\000\001\029\000\000\000}\001\029\000\000\001m\000\000\000\000\000\000\0125\000\000\000}\000\000\001\029\000\000\001\029\000\000\001\029\000\000\001m\001m\001m\000\000\001m\001m\000\000\000\000\000\000\000\000\001\029\000\000\000\000\000\000\000\000\000\000\001\029\000}\000\000\000\000\000\000\001m\000\000\000}\000\000\000\000\000\000\000\000\001\029\000\000\000\000\000\000\001m\001\029\001\029\001\029\001\197\000\000\000\000\000\000\000\000\001\197\000\000\015N\001\197\000\000\002b\000\000\000\000\001\029\000\000\000\000\000\000\000}\001\197\000\000\000\000\000\000\001\197\000\000\000\000\000\000\000\000\001\029\001\029\001\029\000\000\001\029\001\029\000\000\001\197\001\202\001\206\000\000\000\000\000\000\001\197\000\000\000\000\000\000\000\000\000\000\015R\000\000\001\029\001\197\000\000\015b\001\197\001\210\001\226\000\000\000\000\001\197\001\197\001\029\015^\000\000\001\238\000\000\000\000\000\000\000\000\000\000\000\000\001\246\000\000\000\000\000\000\001\197\0009\001\242\002r\001\197\000\000\0009\002~\0009\002\146\004\006\004\018\000\000\015f\001\197\001\197\004\030\0009\001\197\001\197\0009\000\000\000\000\000\000\0009\b)\000\000\000\000\001\197\000\000\000\000\000\000\000\000\004\"\000\000\001\197\000\000\000\000\000\000\000\000\000\000\000\000\0009\000\000\000\000\0009\001\197\000\000\0009\000\000\000\000\000\000\000\000\0009\000\000\000\000\000\000\000\000\0009\0009\0009\000\000\000\000\000\000\000\000\000\000\000\000\0009\0009\004*\000\000\004.\000\000\0036\002\158\000\000\000\000\002\214\0009\006z\000\000\0009\002\218\000\000\000\000\000\000\004E\000\000\000\000\004E\0009\000\000\006\154\0009\000\000\000\000\000\000\003:\b)\004E\b\178\000\000\0009\000\000\000\000\0009\000\000\000\000\b\246\000\000\003F\000\000\000\000\rr\001\190\004E\000\000\000\000\0009\000\000\002\146\004E\000\000\003\210\000\000\000\000\000\000\003\214\004E\003\222\004E\n\138\005R\004E\000\000\000\000\004E\000\000\004E\002\194\000\000\000\000\000\000\000\000\005V\000\000\004E\000\000\000\000\000\000\004E\000\000\005^\005b\004E\000\000\000\000\000\000\004E\000\000\000\000\000\000\004E\000\000\000\000\000\000\000\000\000\000\004E\004E\000\000\000\000\004E\000\000\r\130\000\000\005f\004E\000\000\000\000\004E\000\000\004.\000\000\000\000\004E\002\194\000\238\000\000\004E\000\000\003!\000\000\000\000\004E\004E\003!\000\000\000\000\003!\000\000\004E\004E\000\000\000\000\004E\000\000\000\000\000\000\003!\000\000\000\000\000\000\003!\000\000\004E\004E\000\000\000\000\004E\004E\000\000\000\000\000\000\000\000\003!\015n\000\000\000\000\004E\000\000\003!\000\000\000\000\004E\000\000\004E\004E\000\000\000\000\003!\025j\000\000\003!\000\000\000\000\000\000\004E\003!\003!\003!\004E\000\000\0036\002\158\000\000\000\000\002\214\000\000\006z\000\000\000\000\002\218\004E\003!\000\000\000\000\000\000\003!\004E\000\000\000\000\006\154\000\000\000\000\004N\000\000\003:\003!\003!\b\178\004E\003!\003!\000\000\000\000\004E\002\194\023.\000\000\003F\000\000\003!\003R\001\190\000\000\000\000\000\000\015\206\003!\002\146\000\000\004E\003\210\003!\000\000\000\000\003\214\000\000\003\222\003!\n\138\005R\000\000\000\000\000\000\004E\004E\000\000\000\000\004E\004E\000\000\000\000\005V\000\000\004^\000\000\000\000\000\000\007\030\000\000\005^\005b\0036\002\158\021\158\004E\002\214\000\000\006z\000\000\000\000\002\218\000\000\000\000\000\000\000\000\004E\000\000\000\000\000\000\000\000\006\154\023\250\000\000\005f\000\000\003:\000\000\000\000\b\178\004.\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003F\000\000\000\000\nz\001\190\000\000\000\000\000\000\000\000\000\000\002\146\006y\006y\003\210\000\000\000\000\000\000\003\214\000\000\003\222\000\000\n\138\005R\000\000\000\000\000\000\000\000\000\000\000\000\006y\006y\000\000\000\000\000\000\005V\000\000\000\000\000\000\006y\000\000\000\000\000\000\005^\005b\0036\002\158\n\146\000\000\002\214\000\000\006z\006y\006y\002\218\000\000\000\000\006y\000\000\006y\006y\006y\000\000\000\000\006\154\0226\006y\005f\000\000\003:\000\000\000\000\b\178\004.\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003F\006y\000\000\nz\001\190\005\154\000\000\000\000\000\000\000\000\002\146\0036\002\158\003\210\000\000\002\214\000\000\003\214\000\000\003\222\002\218\n\138\005R\000\000\000\000\005\158\000\000\003\218\000\000\000\000\000\000\000\000\000\000\000\000\005V\003:\000\000\000\000\000\000\000\000\000\000\000\000\005^\005b\004\194\000\000\n\146\000\000\003F\000\000\000\000\003R\001\190\000\000\000\000\000\000\000\000\000\000\002\146\000\000\000\000\003\210\000\000\000\000\022\150\003\214\005f\003\222\005F\000\000\005R\000\000\004.\000\000\000\000\000\000\000\000\000\000\000\000\b\169\000\000\000\000\005V\000\000\000\000\0036\002\158\000\000\000\000\002\214\005^\005b\000\000\005\162\002\218\000\000\000\000\000\000\000\000\000\000\000\000\b\169\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003:\000\000\005\234\000\000\000\000\005f\000\000\006f\000\000\b\154\000\000\004.\000\000\003F\000\000\000\000\003R\001\190\000\000\000\000\000\000\000\000\000\000\002\146\000\000\000\000\003\210\000\000\011\241\000\000\003\214\011\241\003\222\005F\000\000\005R\002\209\002\209\000\000\000\000\002\209\011\241\000\000\000\000\000\000\002\209\000\000\005V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\005b\011\241\005\162\000\000\002\209\000\n\000\000\011\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\241\002\209\000\000\011\241\002\209\002\209\000\000\005f\011\241\b\169\000\000\002\209\000\000\004.\002\209\000\000\000\000\002\209\002\209\000\000\002\209\002\209\000\000\002\209\011\241\004-\004-\000\000\011\241\004-\000\000\000\000\000\000\000\000\004-\002\209\000\000\000\000\011\241\011\241\004-\000\000\011\241\002\209\002\209\000\000\002\209\000\000\027f\004-\022\230\000\000\000\000\022\254\000\000\000\000\000\000\000\000\000\000\011\241\000\000\000\000\004-\000\000\000\000\004-\004-\002\209\000\000\000\000\000\000\002\209\004-\002\209\000\000\004-\000\000\000\000\000\238\004-\003!\004-\004-\000\000\004-\003!\000\000\000\000\003!\003!\000\000\000\000\000\000\000\000\003!\000\000\004-\003!\003!\000\000\000\000\000\000\003!\000\000\004-\004-\000\000\003!\000\000\000\000\000\000\003!\000\000\000\000\003!\015n\000\000\000\000\000\000\000\000\003!\000\000\000\000\003!\015n\000\000\000\000\000\000\004-\003!\000\000\000\000\003!\000\000\004-\000\000\000\000\003!\003!\003!\003!\003!\000\000\000\000\000\000\003!\003!\003!\003!\000\000\000\000\000\000\000\000\003!\000\000\000\000\000\000\003!\003!\000\000\000\000\000\000\003!\000\000\000\000\000\000\003!\003!\003!\025r\000\000\003!\003!\000\000\003!\015n\003!\003!\025\162\000\000\003!\003!\000\000\000\000\000\000\000\000\012)\015\206\003!\003!\000\000\012)\003!\003!\012)\000\000\015\206\003!\003!\003!\000\000\000\000\003!\000\000\012)\000\000\000\000\000\000\012)\000\000\000\000\000\000\000\000\003!\0121\000\000\000\000\003!\000\000\000\000\012)\000\000\000\000\000\000\000\000\000\000\012)\003!\003!\017R\000\000\003!\003!\000\000\000\000\012)\000\000\000\000\012)\000\000\000\000\000\000\000\000\012)\012)\0036\002\158\015\206\003!\002\214\000\000\006z\000\000\000\000\002\218\000\000\000\000\000\000\000\000\012)\000\000\000\000\000\000\012)\006\154\000\000\000\000\000\000\000\000\003:\000\000\000\000\b\178\012)\012)\002Z\000\000\012)\012)\000\000\000\000\000\000\003F\000\000\000\000\b\222\001\190\012)\005\001\000\000\000\000\026\154\002\146\005\001\012)\003\210\005\001\000\000\000\000\003\214\000\000\003\222\000\000\n\138\005R\012)\005\001\000\000\000\000\000\000\005\001\000\000\000\000\000\000\000\000\000\000\005V\000\000\000\000\000\000\000\000\000\000\005\001\000\000\005^\005b\000\000\000\000\005\001\000\000\000\000\000\000\000\000\000\000\007\174\000\000\000\000\005\001\000\000\000\000\005\001\000\000\000\000\000\000\000\000\005\001\005\001\000\238\005f\000\000\000\000\005\005\000\000\000\000\004.\000\000\005\005\000\000\000\000\005\005\000\000\005\001\005\001\000\000\000\000\005\001\000\000\000\000\000\000\005\005\000\000\000\000\000\000\005\005\000\000\005\001\005\001\000\000\000\000\005\001\005\001\000\000\000\000\000\000\000\000\005\005\012\201\012\201\000\000\000\000\000\000\005\005\000\000\000\000\000\000\000\000\005\001\007\174\000\000\000\000\005\005\000\000\000\000\005\005\012\201\012\201\007\006\005\001\005\005\005\005\000\238\000\000\000\000\012\201\005\177\000\000\000\000\000\000\000\000\005\177\000\000\000\000\005\177\000\000\005\005\005\005\012\201\012\201\005\005\000\000\000\000\012\201\005\177\012\201\012\201\012\201\005\177\000\000\005\005\005\005\012\201\000\000\005\005\005\005\000\000\000\000\000\000\000\000\005\177\000\000\000\000\000\000\000\000\000\000\005\177\000\000\000\000\012\201\000\000\005\005\000\000\000\000\000\000\005\177\000\000\000\000\005\177\000\000\000\000\000\000\005\005\005\177\005\177\000\238\025J\000\000\000\000\000\000\000\000\000\000\0036\002\158\000\000\000\000\002\214\000\000\000\000\005\177\000\000\002\218\000\000\005\177\000\000\000\000\000\000\000\000\006&\000\000\000\000\000\000\000\000\005\177\005\177\021*\003:\005\177\005\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\177\000\000\003F\000\000\000\000\003R\001\190\005\177\000\000\000\000\000\000\000\000\002\146\000\000\000\000\003\210\000\000\000\000\005\177\003\214\000\000\003\222\005F\005\249\005R\000\000\000\000\000\000\000\000\000\000\002\158\000\000\000\000\002\214\000\000\000\000\005V\000\000\002\218\000\000\000\000\000\000\000\000\005\249\005^\005b\000\000\005\162\000\000\000\000\002\222\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\226\000\000\000\000\000\000\000\000\000\000\000\000\005f\003\014\001\190\000\000\b\154\000\000\004.\000\000\002\146\000\000\000\000\003\026\001\202\001\206\000\000\007\234\007\238\007\250\000\000\000\000\005R\000\000\000\000\000\000\000\000\000\000\002n\000\000\005\198\000\000\001\210\001\226\000\000\000\000\0036\002\158\000\000\000\000\002\214\001\238\005^\005b\000\000\002\218\000\000\000\000\001\246\000\000\000\000\000\000\000\000\000\000\001\242\002r\000\000\000\000\000\000\002~\003:\002\146\004\006\004\018\000\000\000\000\005f\b\002\004\030\000\000\000\000\b\026\004.\003F\000\000\000\000\003R\001\190\000\000\000\000\000\000\006\002\000\000\002\146\000\000\004\"\003\210\0036\002\158\000\000\003\214\002\214\003\222\005F\000\000\005R\002\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005V\000\000\000\000\000\000\003:\000\000\000\000\015V\005^\005b\000\000\005\162\000\000\000\000\000\000\000\000\000\000\003F\000\000\000\000\003R\001\190\000\000\000\000\000\000\000\000\000\000\002\146\000\000\000\000\003\210\000\000\005f\000\000\003\214\006\014\003\222\005F\004.\005R\000\000\0036\002\158\000\000\000\000\002\214\000\000\000\000\000\000\000\000\002\218\005V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\005b\000\000\005\162\000\000\000\000\003:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003F\000\000\000\000\003R\001\190\005f\000\000\000\000\005\253\000\000\002\146\004.\000\000\003\210\0036\002\158\000\000\003\214\002\214\003\222\005F\000\000\005R\002\218\000\000\000\000\000\000\000\000\005\253\000\000\000\000\000\000\000\000\000\000\005V\000\000\000\000\000\000\003:\000\000\000\000\000\000\005^\005b\000\000\005\162\000\000\000\000\000\000\000\000\000\000\003F\000\000\000\000\003R\001\190\000\000\000\000\000\000\000\000\000\000\002\146\000\000\000\000\003\210\000\000\005f\000\000\003\214\011r\003\222\005F\004.\005R\000\000\0036\002\158\000\000\000\000\002\214\000\000\000\000\000\000\000\000\002\218\005V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\005b\000\000\000\000\000\000\000\000\003:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003F\000\000\000\000\003R\001\190\005f\000\000\000\000\011~\000\000\002\146\004.\000\000\003\210\0036\002\158\000\000\003\214\002\214\003\222\005F\000\000\005R\002\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005V\000\000\000\000\000\000\003:\000\000\000\000\000\000\005^\005b\000\000\005\162\000\000\000\000\000\000\000\000\000\000\003F\000\000\000\000\003R\001\190\000\000\000\000\000\000\000\000\000\000\002\146\000\000\000\000\003\210\000\000\005f\000\000\003\214\011\138\003\222\005F\004.\005R\000\000\0036\002\158\000\000\000\000\002\214\006!\000\000\000\000\000\000\002\218\005V\000\000\002\158\000\000\000\000\002\214\000\000\000\000\005^\005b\002\218\005\162\000\000\000\000\003:\006!\000\000\000\000\000\000\000\000\000\000\000\000\002\222\000\000\000\000\000\000\000\000\003F\000\000\000\000\003R\001\190\005f\002\226\000\000\000\000\000\000\002\146\004.\000\000\003\210\003\014\001\190\000\000\003\214\000\000\003\222\005F\002\146\005R\000\000\003\026\000\000\000\000\000\000\007\234\007\238\007\250\000\000\000\000\005R\005V\000\000\000\000\000\000\000\000\006\169\006\242\000\000\005^\005b\006\169\005\162\000\000\006\169\000\000\000\000\000\000\000\000\000\000\005^\005b\000\000\000\000\006\169\000\000\000\000\000\000\006\169\000\000\000\000\000\000\000\000\005f\000\000\000\000\000\000\000\000\000\000\004.\006\169\000\000\000\000\000\000\005f\b\002\006\169\007^\000\000\b\026\004.\001\153\000\000\000\000\000\000\006\169\001\153\000\000\006\169\001\153\000\000\000\000\000\000\006\169\006\169\000\238\000\000\000\000\000\000\001\153\000\000\000\000\000\000\001\153\000\000\000\000\000\000\000\000\000\000\006\169\000\000\000\000\000\000\006\169\000\000\001\153\000\000\000\000\000\000\000\000\000\000\001\153\000\000\006\169\006\169\000\000\000\000\006\169\006\169\000\000\001\153\000\000\000\000\001\153\000\000\000\000\000\000\000\000\001\153\001\153\001\153\001\201\000\000\005\181\006\169\000\000\001\201\000\000\005\181\001\201\000\000\005\181\000\000\000\000\001\153\000\000\000\000\000\000\001\153\001\201\000\000\005\181\000\000\001\201\000\000\005\181\000\000\000\000\001\153\001\153\000\000\000\000\001\153\001\153\000\000\001\201\000\000\005\181\017b\000\000\000\000\001\201\000\000\005\181\000\000\000\000\000\000\000\000\000\000\001\153\001\201\000\000\005\181\001\201\001\153\005\181\000\000\000\000\001\201\001\201\005\181\005\181\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\201\000\000\005\181\000\000\001\201\000\000\005\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\201\001\201\005\181\005\181\001\201\001\201\005\181\005\181\000\000\000\000\000\000\000\000\000\000\000\000\001\201\011\225\005\181\002\158\011\225\000\000\027N\001\201\000\000\005\181\000\000\027R\021\006\000\000\011\225\000\000\000\000\000\000\001\201\000\000\005\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\225\000\000\000\000\000\000\000\000\000\000\011\225\000\000\000\000\000\000\000\000\004E\001\002\001\190\000\000\011\225\004E\000\000\011\225\004E\000\000\000\000\000\000\011\225\000\000\000\000\000\000\000\000\000\000\004E\000\000\027V\000\000\004E\000\000\000\000\000\000\000\000\000\000\011\225\000\000\000\000\000\000\011\225\000\000\004E\000\000\000\000\000\000\000\000\000\000\004E\027Z\011\225\011\225\000\000\000\000\011\225\000\000\000\000\004E\000\000\000\000\004E\000\000\000\000\000\000\000\000\004E\002\194\000\000\000\000\000\000\000\000\011\225\000\000\000\000\007\201\007\201\000\000\000\000\007\201\000\000\000\000\004E\000\000\007\201\000\000\004E\000\000\000\000\000\000\015\250\000\000\000\000\000\000\000\000\000\000\004E\004E\000\000\007\201\004E\004E\006\242\000\000\000\000\000\000\004E\000\000\000\000\004E\007\030\000\000\007\201\000\000\000\000\007\201\007\201\004E\004E\004E\000\000\000\000\007\201\004E\000\000\007\201\004E\000\000\004E\007\201\000\000\007\201\007\201\000\000\007\201\004E\004E\000\000\000\000\000\000\004E\004E\007^\000\000\000\000\000\000\007\201\000\000\000\000\000\000\000\000\000\000\004E\004E\007\201\007\201\000\000\000\000\004E\002\194\000\238\000\000\000\000\000\000\007\174\000\000\000\000\004E\000\000\000\000\004E\000\000\000\000\000\000\004E\004E\002\194\000\238\007\201\000\000\000\000\000\000\001U\000\000\007\201\000\000\000\000\001U\004E\004E\001U\004E\004E\004E\000\000\004E\000\000\000\000\000\000\000\000\001U\000\000\001U\000\000\001U\004E\004E\000\000\000\000\004E\004E\001\202\001\206\022:\000\000\000\000\001U\000\000\000\000\000\000\004E\000\000\001U\000\000\000\000\000\000\004E\000\205\000\000\002\138\001\226\000\000\000\205\000\000\001U\000\205\000\000\000\000\001\238\001U\001U\000\238\000\000\000\000\000\000\000\205\000\000\000\000\000\000\000\205\000\000\001\242\002r\000\000\000\000\001U\002~\000\000\002\146\004\006\004\018\000\205\000\000\000\000\000\000\004\030\000\000\000\205\000\000\001U\001U\001U\000\000\001U\001U\000\000\000\205\000\000\000\000\000\205\000\000\000\000\004\"\000\000\000\205\000\205\000\238\000\000\000\000\000\000\001U\000\209\000\000\000\000\000\000\000\000\000\209\000\000\000\000\000\209\000\205\001U\000\000\000\000\000\205\000\000\000\000\000\000\000\000\000\209\000\000\000\000\000\000\000\209\000\205\000\205\000\000\000\000\000\205\000\205\000\000\000\000\000\000\000\000\000\000\000\209\000\000\000\000\000\000\004M\000\000\000\209\000\000\000\000\000\246\000\205\006\165\002\014\000\000\000\000\000\209\006\165\000\000\000\209\006\165\000\000\000\205\017\134\000\209\000\209\000\238\004M\000\000\000\000\006\165\000\000\000\000\000\000\006\165\000\000\000\000\000\000\000\000\017\138\000\209\000\000\000\000\000\000\000\209\017\178\006\165\000\000\000\000\000\000\000\000\000\000\006\165\000\000\000\209\000\209\000\000\016\226\000\209\000\209\000\000\006\165\016\250\000\000\006\165\000\000\000\000\000\000\000\000\006\165\006\165\000\000\005\169\000\000\000\000\000\209\000\000\005\169\018.\000\000\005\169\000\000\000\000\000\000\000\000\006\165\000\209\0172\000\000\006\165\005\169\000\000\017\022\018B\005\169\000\000\004M\004M\000\000\006\165\006\165\016\146\000\000\006\165\006\165\000\000\005\169\000\000\000\000\000\000\005\r\006\242\005\169\018R\000\000\005\r\000\000\000\000\005\r\000\000\006\165\005\169\000\000\000\000\005\169\000\000\000\000\000\000\005\r\005\169\005\169\000\000\005\r\000\000\000\000\007!\000\000\000\000\007!\000\000\000\000\000\000\000\000\000\000\005\r\005\169\000\000\000\000\000\000\005\169\005\r\007^\000\000\000\000\007!\007!\000\000\007!\007!\005\169\005\169\000\000\005\r\005\169\005\169\000\000\000\000\005\r\005\r\000\238\011\145\000\000\000\000\000\000\000\000\011\145\007!\000\000\011\145\000\000\005\169\000\000\000\000\005\r\000\000\000\000\000\000\000\000\011\145\000\000\000\000\000\000\011\145\000\000\000\238\000\000\000\000\005\r\005\r\000\000\000\000\005\r\005\r\000\000\011\145\000\000\000\000\000\000\000\000\000\000\011\145\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\r\011\145\000\000\000\000\011\145\000\000\007!\000\000\007!\011\145\000\000\000\000\000\000\000\000\001\202\002^\000\000\000\000\002b\000\000\005\254\000\000\000\000\005\194\007!\011\145\t\138\000\000\007!\011\145\007!\000\000\001\210\001\226\007!\000\000\000\000\000\000\000\000\011\145\011\145\001\238\000\000\011\145\011\145\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002j\002r\000\000\000\000\000\000\002~\011\145\002\146\004\006\004\018\000\000\000\000\000\000\000\000\020\222\000\000\026F\nn\000\000\004\029\000\000\004\021\000\000\000\000\004\029\000\000\004\021\004\029\000\000\004\021\000\000\004\"\000\000\000\000\000\000\000\000\000\000\004\029\000\000\004\021\015f\004\029\000\000\004\021\000\000\000\000\000\000\000\000\000\000\000\000\026R\000\000\000\000\004\029\000\000\004\021\000\000\000\000\000\000\004\029\000\000\004\021\000\000\000\000\000\000\000\000\000\000\020\242\004\029\000\000\004\021\004\029\000\000\004\021\000\000\000\000\004\029\000\000\004\021\000\000\000\000\000\000\0045\000\000\000\000\000\000\000\000\0045\000\000\000\000\0045\000\000\004\029\000\000\004\021\000\000\004\029\000\000\004\021\000\000\0045\000\000\000\000\000\000\0045\000\000\004\029\004\029\004\021\004\021\004\029\004\029\004\021\004\021\000\000\000\000\0045\000\000\000\000\000\000\000\000\000\000\0045\000\000\000\000\000\000\000\000\004\029\000\000\004\021\000\000\0045\000\000\000\000\0045\000\000\000\000\000\000\016\186\0045\019\186\000\000\004\005\000\000\000\000\000\000\000\000\004\005\000\000\000\000\004\005\000\000\000\000\000\000\000\000\0045\000\000\000\000\000\000\0045\004\005\000\000\000\000\000\000\004\005\000\000\000\000\000\000\000\000\0045\0045\000\000\000\000\0045\0045\000\000\004\005\000\000\000\000\000\000\004%\000\000\004\005\000\000\000\000\004%\000\000\004\r\004%\000\000\0045\004\005\004\r\000\000\004\005\004\r\000\000\000\000\004%\004\005\000\000\020\162\004%\000\000\000\000\004\r\000\000\000\000\000\000\004\r\000\000\000\000\000\000\000\000\004%\004\005\000\000\000\000\000\000\004\005\004%\004\r\000\000\000\000\000\000\000\000\000\000\004\r\000\000\004\005\004\005\000\000\004%\004\005\004\005\000\000\000\000\004%\000\000\004\r\000\000\000\000\000\000\000\000\004\r\000\000\000\000\000\000\000\000\000\000\004\005\004=\000\000\004%\000\000\000\000\004=\000\000\004Y\004=\004\r\024\026\000\000\000\246\000\000\000\000\002\162\004%\004%\004=\000\000\004%\004%\004=\004\r\004\r\003\146\000\000\004\r\004\r\004Y\000\000\000\000\000\000\000\000\004=\000\000\000\000\004%\000\000\000\000\004=\003\150\000\000\000\000\004\r\000\000\000\000\016~\017\230\000\000\000\000\000\000\004=\000\000\000\000\020N\024F\004=\000\000\016\226\000\000\000\000\000\000\000\000\016\250\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004=\000\000\000\000\n\246\000\000\000\000\000\000\017\002\000\000\001\202\001\206\000\000\000\000\000\000\004=\004=\000\000\000\000\004=\004=\000\000\017\022\017B\000\000\000\000\004Y\004Y\001\210\001\226\000\000\000\000\000\000\000\000\000\000\000\000\004=\001\238\000\000\000\000\000\000\000\000\000\000\021\134\001\202\001\206\022\154\020\202\000\000\000\000\001\242\002r\000\000\000\246\000\000\002~\002\162\002\146\004\006\004\018\000\000\000\000\002\138\001\226\004\030\000\000\027\154\000\000\000\000\001\202\001\206\001\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\"\003\150\000\000\001\242\002r\000\000\001\210\016~\002~\000\000\002\146\004\006\004\018\000\000\000\000\000\000\024F\004\030\000\000\016\226\000\000\000\000\000\000\000\000\016\250\000\000\000\000\000\000\001\242\002\130\000\000\000\000\000\000\002~\004\"\002\146\004\006\004\018\000\000\000\000\017\002\000\000\004\030\000\000\027F\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\022\017B\000\000\000\000\004\129\004\"\000\000\000\000\004\189\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\021\134\000\000\000\000\025\238"))
+ ((16, "C\170P\226Ff\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\021HFf\000\000\000\000\020XFfC\170\020\182\000-\000[\\(\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\021\238\006\168\000\218\000\000\003\188\t|\000\000\001\208\003\232\nt\000\000\000\244\004\198\011l\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\220\000\000\000\000\000\000\0046T\016\000\000\000\000\000\000\005.\000\000\000\000\000\000\005\022\005\b\000\000\000\000T\016H\254\020X\021\178^\128\020X\\\142Mj\020XB\146\000\000B\146\000\000\027\158\004\246\000\000\005.\000\000\000\000\000\000\002J\000\000\027\158\000\000\006&v\246]\160d\194\000\000\132l\134\028\000\000LP_\014\000\000X\\\026\206K\200\005.p\026FfC\170\000\000\000\000Mj\020XF\138B\146\007\012v\246\000\000\128\178FfC\170P\226\020X\000\000\000\000\016x\025\186\001N\b\198\000\000\002\138\b\252\000\000\000\000\000\000\000\000\000\000\020X\000\000A\206i\164C\170\000\000\000\000P\206\020XZ\024W\200\000\000\004\002\000\000\000\000\005\242\000\000\000\000H\166\004\002\024\138\003\130\0020\000\000\000\000\003\172\000\000\021\178\006f\006\154\020X\028\254\020XC\170C\170\000\000P\212P\148\020X\028\254E\166\020X\000\000\000\000\000\000P\226\020X\000\000\000\248\000\000W\200y\188zJ\000\000\b\198\000\000\n\"\000\000\000\000C,T\016\134h\000\000h\142\134h\000\000h\142h\142\000b\006:\0008\000\000\020\190\000\000\006\220\000\000\000\000\t\014\000\000\000\000\000\000h\142\005.\000\000\000\000V\222T\016T\132_\014\000\000\000\000N*\000b\000\000\000\000_\014\007\026T\016\000\000O _\014P\022\000\000\000\000\000\000\n\198\000\000h\142\000\000\001\000\1310\000\000T\016\005\216T\016\000\000\022\\\b&\005.\000\000\000\000\023\224\000\000\006\208\000\000Y\128\011\190\000\000\007\128h\142\011\230\000\000\012\182\000\000\007\200\000\000\000\000\004\184\000\000\000\000\000\000\021 4W\200P\206\020XW\200\000\000\000b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000M:\027v\000\000\000\000\000\000\001\244&\174t<\000\000\000\000P\206\020XW\200\000\000\000\000{hW\200\136.zJ\000\000\136v\000\000W\200\000\000\000\000X\180\000\000\000\000\000\000\b\162\000\000\022\168\000\000\000\000z\214\000\000\136\208{\030\000\000\137\018\t\002\000\000\000\000z\214\000\000\004\024\000\000\000\000DHt\200\000\000\000\000\000\000Bn\023|\019\252\023\176\000\000\000\000\000\000\000\000\004\250\000\000\000\000Z\204\b\164\t`\000\017T\016\002\204\n\204\000\000\000\000\t\246\t`\007X\000\000i\186P\234P\148\020X\028\254\000-\000\018\0020\000\000\n>\021\178\021\178\000-\000\018\000\018\021\178\000\000jL\0050B\146\b\198\000\236\137`\000\000T\016ebT\016_ f\002T\016\000\144T\016f\156\000\000\000\000\020d\0008_\192\b\130\0008`\024\000\000j\230\0050\000\000\021\178k\128\000\000\007\196\t\190`\184\000\000\000\000\000\000\000\000\000\000\000\000\001B\000\000\000\000\003\144\000\000\007|\028\254\000\000\\\192E\166\000\000\031\138\000\000\000\000\021\178\002\152\000\000\000\000\000\000\000\000[\132\000\000\001\200\000\000UP\001\130\005\"\000\000\0226V\170P\226\020XG,P\226\020X\016x\016x\000\000\000\000\000\000\000\000\001\240\024&B\188\000\000Q\150RJP\212\020X\028\254\007h\021\178\000\000\004*\000\000R\254S\178{\182I\190T\016\002\128\000\000P\226\020X\000\000u\016\020Xy\188W\200E\186\000\000P\226\020Xw\\\004~\000\000W\200A\012T\016\003x\007X\012<\000\000\000\000\000\000H\166\003\138\003\138\000\000\012Bp\156\000\000P\206\020XW\200\025R\000\000P\226\020X\016x\0226\016x\002\232\023\240\000\000\000\000\016x\012\014\000\000\r\000\000\000\016x\003\224\rX\000\000'\166\000\000\b\196\000\000\000\000\026\022\000\000\017p\023.\000\000\000\000\000\000\000\000\005\226\000\000\000\000\027\014\000\000\028\006\000\000\028\254\000\000\018h\024&\000\000\000\000\000\000Ff\000\000\000\000\000\000\000\000\029\246\000\000\030\238\000\000\031\230\000\000 \222\000\000!\214\000\000\"\206\000\000#\198\000\000$\190\000\000%\182\000\000&\174\000\000'\166\000\000(\158\000\000)\150\000\000*\142\000\000+\134\000\000,~\000\000-v\000\000.n\000\000/f\000\0000^\020XW\200ZJI\146\003\138\014 l\012W\200\000\000\000\000\000\000h\142\000\000\028\018\134\028\000\000\026\"T\016\029\220\r\164\000\000\000\000\000\000\000\000l\012\000\000\000\000\005\242\014V\000\000I\128\000\000\000\000\135\176\000\000\007:\000\000\000\000K\200\003\138\r\202T\016\t\148\000\000\000\000\b\188\005.\000\000T\016\n@\000\000\000\000\r\252\000\000\000\000\000\000JjT\016\nP\000\000\000\000\030*\000\000\000\000{\254\000\000\031\"|\138\000\000 \026|\210\000\000!\018\t\250\000\000\000\000\000\000\000\000\"\nW\200#\002p\234p\234\000\000\000\000\000\0001V\000\000\007\204\000\000\000\000\000\000q\140\000\000\000\000\002\138\023\248\000\000\t*\000\000\000\000]bKl\000\000\000\000\t\188\000\000\000\000\000\000\n\128\000\000\000\000\000\000\016x\004\216\024\232\000\000\t`\000\000\005\208\000\0002N\000\000\n\180\000\000\006\200\000\0003F\000\000\014\204\007\192\000\0004>lt\000\000(\158\000\000\t\218\b\184\000\00056\000\000\011\150\t\176\000\0006.\000\000q\150\n\168\000\0007&\t\234\025\016\000\000\n\210\011\160\000\0008\030\000\000\011\216\012\152\000\0009\022\000\000\r\n\r\144\000\000:\014\014\136\000\000;\006\015\128\019`\000\000\000\000\000\000\011\026\000\000\000\000\012\186\000\000\000\000\015n\000\000\012*\000\000\000\000\000\000\014\222\000\000\015\004\000\000\000\000J~\003\138\015\192p\156_\014\000b\000\000\000\000p\156\000\000\000\000\000\000p\156\000\000\015\156\000\000\000\000\000\000\000\000\000\000\000\000;\254W\200\000\000\000\000\015\232\000\000<\246\000\000=\238\000\000#\250\000\000\000\000\n\184\000\000\000\000W\200\000\000\000\000}j\011\202\000\000\000\000G,\000\000\011\238\000\000\000\000V\020\000\000\rh\000\000\000\000\001\130\011\254\000\000\000\000\0226\022\028\b\198\000\000A\214\000\000!,\025\160\021\220\000\000\000\000\r\150\000\000\000\000\001\238\025\030V\180\000\000\025\030\000\000\012\246\000\000\000\000\r\172\000\000\000\000g>\b\n\004H\000\000\000\000\r@\000\000\000\000\r\200\000\000\000\000\000\000\020X\028\254\005\168\000\000\000\000\023Z\003\130\0020\003\136\028\254w\228\021\178\001B\028\254xb\015\144\000\000\000\000\003\136\000\000H\232\019\248\021\204\000\000\t\144\016\002\000\000\016\000\000V_\014\006\196\000\000\015\232\015vK\200\r(T\016\030\128\0204\014\n\004\248\000\000\031x\016N\000\000\006\196\000\000\000\000\016^_\014aX\000\000g\144_\014\016*_\014m\012a\248\001N\015\236\000\000\000\000\000\000\020X\128\252\000\000W\200p\234\000\000\000\000\016b\000\000\000\000\000\000>\230\016\146y\188?\222h<\000\000\000\000HJ\000\000\005\128\000\000L\136\000\000\022\222\000\000\021\178\006\026\000\000\128\178\000\000\020X\028\254\128\178\000\000\025D\025\186\001N\005.\130\144\021\178}\248p\234\000\000\005r\b\176\0020\003\136p\234\132\224\003\130\0020\003\136p\234\132\224\000\000\000\000\003\136p\234\000\000FfC\170W\200\027B\000\000\000\000FfC\170P\148\020X\028\254\128\178\000\000\020\182\000-\000[\015\200T\016\012\142\016\146\131P\000\000p\234\000\000H\232\019\248\021\204x\186\023\228\t\236~,\b\130\015\234\020Xp\234\000\000\020Xp\234\000\000h\142ff\019\134\002\222\001N\0008N\234\000\000\001N\0008N\234\000\000\025D\005r\t\168\0212\012\180\000\000N\234\000\000\0020\015\234\021\178p\234\134\222\003\130\0020\015\236\021\178p\234\134\222\000\000\000\000\b`\000\000O\224\000\000\021\178\131\132N\234\000\000\b`\000\000H\254\020X\021\178p\234\000\000H\232\019\248\021\204rFC\186\026\222\019\170\002\142\000\000\r\216\027\158\000\017\000\000\016h\016 \024\196\020XT\184T\016\0118\000\000W\150\001N\005\204\011\246\000\000\011\228\000\000\016~\016\014T\016O(\000\000\0032\004\212\r\200\000\000\r6\000\000\016\136\016 K\200\r\206T\016K\182O(\000\000UP\020X\024\196\016\202\n$\001N\000\000\r\200\024\196T\016\012~\000b\000\000T\016\007\152\t,\000\000\000\000mf\000\000\000\000\r\228\024\196m\228O(\000\000\020XT\016\r(T\016V\\O(\000\000\014<\000\000\000\000O(\000\000\000\000W\150\000\000p\234\132\238\019\170\002\142\r\216\016\182\016h\024\196p\234\132\238\000\000\000\000\019\170\002\142\r\216\016\190\016HM\252LZ_\014\016\206M\252h\142\020\184\016\218M\252_\014\016\230M\252n\132o\004\000\000\129\140\000\000\000\000p\234\134\236\019\170\002\142\r\216\016\224\016nM\252p\234\134\236\000\000\000\000\000\000ff\000\000\000\000\000\000\000\000\000\000\000\000N\234\000\000\133\128\020\026A\228\017\002v\246\000\000\128\178\133\128\000\000\000\000\1358\020\026A\228\017\004\016\158]\160\135\176\006\196\017H\000\000\000\000o\130rF\020X\000\000~\200\021\204\000\000\000\000\128\178\1358\000\000\000\000\000\000y6DlD\228\006\196\017J\000\000\000\000\000\000rF\020X\000\000\006\196\017N\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014`C\186\019\170\002\142\r\216\017 r\182\023\204\020XZ\024j\190\020(\001N\006\196\017*\nt\000\000\000\000\016\220\000\000\000\000a\152\000\000\b\022\014\132\000\000\r\212\000\000\0178\016\202T\016d\240\017F\n\158\000\000\000\000\017\004\000\000\000\000\020F\0032\014\210\000\000\017Zs8\137\172\003\138\016\248T\016\014r\000\000\000\000\017\012\000\000\000\000\000\000a\152\000\000\0070\014\234\000\000\014\204\000\000\017l\016\250K\200\000\000\017vs\186\137\248\003\138\017\026T\016\015\024\000\000\000\000\017,\000\000\000\000\000\000\020X\000\000a\152\000\000\020z\020X\023\204\023\204u\168Ff\020X\128\252W\200\021\162\000\000\012\020\001N\000\000\014\012\023\204T\016\014n\b\198\000\000\020XW\200r\182\023\204\014\154\023\204\000\000D\142Et\000\000bR\000\000\000\000b\238\000\000\000\000c\138\000\000\014\192\023\204d&\128\252W\200\021\162\000\000\000\"\000\000\000\000M\252\r\026\000\000\000\000d.\017\144\000\000a\152\000\000\023\204d.a\152\000\000\020XT\016a\152\000\000\015\136\000\000\000\000a\152\000\000\000\000j\190\000\000\129\192M\252\017T\023\204\130\\r\182\000\000p\234\133\142\019\170\002\142\r\216\017\174r\182p\234\133\142\000\000\000\000\000\000\135\248P\206\000\000\000\000\000\000\000\000\000\000\000\000\132\022p\234\000\000\133\128\000\000\000\000\000\000\000\000p\234\135\248\000\000\017\234\000\000\000\000\132\022\017\236\000\000p\234\135\248\000\000\000\000\015\222\000\000\000\000i4\0032\000\000\000\000DH\000\000T\016\015\242\000\000j\190\015\240\000\000\000\000\000\000\014\192\000\000\000\000\000\000P\212\020X\028\254\006\178\000\000Mt\000\000\007p\000\000\000*\000\000\000\000\017\242\000\000\018\026y\188\000\000@\214\017\252\000\000\000\000\017\248\026R\028B\021\204v0\023\228\020X\000\000\128\178\000\000\000\000\000\000\000\000\000\000\000\000\000\000v8\023\228\020X\000\000\015\"v\246\000\000\128\178\000\000\017\254\026R\028B\128\178\000\000\018\020\000\000\000\238\t\214\020X`\226\000\000\000\000\028\190y\242\000\000\000\000\017\184\000\000\018\bT\016\000\000\r\234\011\174\000b\000\000\000\000T\016\004R\006B\000\000T\016\012\018\006\196\018>\000\000\000\000\127\"\000\000\000\000]\160\000\000\128\178\000\000\0182\026R\029:N\234\000\000\000\000\000\000\000\000\015h\127\188]\160\000\000\128\178\000\000\0184\026R\029:N\234\000\000\016 \000\000\000\000\b\n\000\000p\234\000\000\018H\000\000\000\000\017\174\000\000\017\188\000\000\017\208\000\000\000\000\\\142\017\216\000\000\000\000%\182\\(\018t\000\000\000\000\000\000\014\242\011D]\232\018x\000\000\000\000\000\000\000\000\000\000\000\000\017\248\000\000\023\228\000\000\017\250\000\000T\016\000\000\014\250\000\000\000\000\017\252\000\000\000\000\0008\000\000\003\210\000\000\000\000\000\000\001\214\000\000\015\196\000\000\018\000\000\000W\200\022\168\000\000\000\000\012<\018\012\000\000\000\000\018\006\r$G,\005.\128:\000\000\000\000\000\000\000\000\000\000YL\000\000\000\000\018\172\000\000\138<\000\000\015\192\018\180\000\000\018\182\000\000G\224G\224[\190[\190\000\000\000\000p\234[\190\000\000\000\000\000\000p\234[\190\0180\000\000\018H\000\000"), (16, "\t)\t)\000\006\001\002\001\190\t)\002\158\002\162\t)\002\206\002f\t)\003\145\t)\018\130\002\218\t)\023\130\t)\t)\t)\025*\t)\t)\t)\001\210\004A\004A\004*\002\222\t)\003\"\003&\t\214\t)\001\206\t)\023\134\003*\000\238\002\226\025.\t)\t)\003\186\003\190\t)\003\194\003\022\003\206\003\214\006\186\006\246\t)\t)\002\150\001\206\006\214\003\030\t)\t)\t)\007\254\b\002\b\014\b\"\001*\005Z\t)\t)\t)\t)\t)\t)\t)\t)\t)\b\150\000\238\t)\015~\t)\t)\003\145\b\162\b\186\t\014\005f\005j\t)\t)\t)\r\162\t)\t)\t)\t)\002N\002~\r\210\t)\006\150\t)\t)\0035\t)\t)\t)\t)\t)\t)\005n\b\022\t)\t)\t)\b.\004V\t\"\0035\t)\t)\t)\t)\012\217\012\217\023\138\n\178\004~\012\217\n\190\012\217\012\217\000\238\012\217\012\217\012\217\012\217\004A\012\217\012\217\001f\012\217\012\217\012\217\003i\012\217\012\217\012\217\012\217\004A\012\217\015\222\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\007\162\007\002\0076\012\217\004\198\012\217\012\217\012\217\012\217\012\217\004A\012\217\012\217\004A\012\217\003\210\012\217\012\217\012\217\000\238\007\166\012\217\012\217\012\217\012\217\012\217\012\217\012\217\000\238\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\004A\012\217\012\217\007n\012\217\012\217\001j\004A\007\018\004A\012\217\012\217\012\217\012\217\012\217\004A\012\217\012\217\012\217\012\217\012\217\000\238\012\217\012\217\007\026\012\217\012\217\000\238\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\012\217\b\006\004A\012\217\012\217\012\217\012\217\001\181\001\181\001\181\001f\015>\001\181\003i\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\014\234\001\181\007\194\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\003j\003n\001\181\000\238\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\006\218\001\181\001\181\001\181\007\250\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\002J\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\027\159\001\181\001\181\018r\007\222\007\002\007R\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\014\174\bF\001\181\005\158\001\181\001\181\007\226\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\181\001\182\001\181\001\181\001\181\001\181\001\181\n]\n]\002\225\007n\012\253\n]\003\149\n]\n]\000\238\n]\n]\n]\n]\001\186\n]\n]\012\253\n]\n]\n]\000\238\n]\n]\n]\n]\002N\n]\000\n\n]\n]\n]\n]\n]\n]\n]\n]\024\194\007\002\b\146\n]\004A\n]\n]\n]\n]\n]\000\238\n]\n]\012\006\n]\002\246\n]\n]\n]\002\225\024\198\n]\n]\n]\n]\n]\n]\n]\004A\n]\n]\n]\n]\n]\n]\n]\n]\n]\n]\n]\003\149\n]\n]\007n\n]\n]\004A\004A\007\002\004A\n]\n]\n]\n]\n]\004\001\n]\n]\n]\n]\t:\000\238\tj\n]\005\241\n]\n]\007\174\n]\n]\n]\n]\n]\n]\n]\n]\n]\n]\n]\n]\n]\003v\n]\n]\n]\n]\n]\003\173\003\173\001r\007n\006\214\003\173\b\250\003\173\003\173\000\238\003\173\003\173\003\173\003\173\000\238\003\173\003\173\006\137\003\173\003\173\003\173\000\238\003\173\003\173\003\173\003\173\001\130\003\173\006>\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\006\137\007\002\004\001\003\173\004&\003\173\003\173\003\173\003\173\003\173\015.\003\173\003\173\006B\003\173\t\005\003\173\003\173\003\173\005\241\bv\003\173\003\173\003\173\003\173\003\173\003\173\003\173\0156\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\b\213\t2\tb\007n\003\173\003\173\003z\003B\b\202\027\143\003\173\003\173\003\173\003\173\003\173\0046\003\173\003\173\003\173\003\173\t:\000\238\tj\003\173\b\006\003\173\003\173\003F\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\003\173\000\238\003\173\003\173\003\173\003\173\003\173\003\161\003\161\018\222\b\206\b\234\003\161\0056\003\161\003\161\t\005\003\161\003\161\003\161\003\161\001\146\003\161\003\161\006~\003\161\003\161\003\161\0022\003\161\003\161\003\161\003\161\018\230\003\161\001\198\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\006\237\b\213\004A\003\161\0026\003\161\003\161\003\161\003\161\003\161\b\029\003\161\003\161\001\218\003\161\007\006\003\161\003\161\003\161\006\237\004A\003\161\003\161\003\161\003\161\003\161\003\161\003\161\004A\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\000\238\t2\tb\001\234\003\161\003\161\004A\004A\007\002\007B\003\161\003\161\003\161\003\161\003\161\001\222\003\161\003\161\003\161\003\161\t:\004A\tj\003\161\004V\003\161\003\161\016Z\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\003\161\006\237\003\161\003\161\003\161\003\161\003\161\t\217\t\217\018\178\007n\b\n\t\217\006\130\t\217\t\217\001\238\t\217\t\217\t\217\t\217\000\238\t\217\t\217\006\149\t\217\t\217\t\217\000\238\t\217\t\217\t\217\t\217\004A\t\217\007\194\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\006\149\007\002\018\186\t\217\000\238\t\217\t\217\t\217\t\217\t\217\005\217\t\217\t\217\001\206\t\217\012f\t\217\t\217\t\217\015\022\016v\t\217\t\217\t\217\t\217\t\217\t\217\t\217\000\238\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\0262\t\217\t\217\007n\t\217\t\217\003\130\003N\t\162\004A\t\217\t\217\t\217\t\217\t\217\002Z\t\217\t\217\t\217\t\217\t\217\000\238\t\217\t\217\004&\t\217\t\217\003R\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\000\238\004A\t\217\t\217\t\217\t\217\t\209\t\209\004\214\001f\003i\t\209\n\134\t\209\t\209\025\018\t\209\t\209\t\209\t\209\003\134\t\209\t\209\004:\t\209\t\209\t\209\003\137\t\209\t\209\t\209\t\209\b\241\t\209\004B\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\007\194\0266\015\134\t\209\001\206\t\209\t\209\t\209\t\209\t\209\005\209\t\209\t\209\000\238\t\209\012~\t\209\t\209\t\209\022f\011\022\t\209\t\209\t\209\t\209\t\209\t\209\t\209\000\238\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\011\026\t\209\t\209\022n\t\209\t\209\002\186\004\146\007\002\b\241\t\209\t\209\t\209\t\209\t\209\007\005\t\209\t\209\t\209\t\209\t\209\025\022\t\209\t\209\b\021\t\209\t\209\025\"\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\000\238\b\241\t\209\t\209\t\209\t\209\t\225\t\225\b\193\007n\007\194\t\225\011\234\t\225\t\225\007\182\t\225\t\225\t\225\t\225\006\214\t\225\t\225\000\238\t\225\t\225\t\225\000\238\t\225\t\225\t\225\t\225\005*\t\225\011\238\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\001\007\002\006\182\t\225\000\238\t\225\t\225\t\225\t\225\t\225\021\218\t\225\t\225\004&\t\225\012\146\t\225\t\225\t\225\014\226\026\198\t\225\t\225\t\225\t\225\t\225\t\225\t\225\bj\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\004\230\t\225\t\225\007n\t\225\t\225\005\018\021\226\b\193\005.\t\225\t\225\t\225\t\225\t\225\005\209\t\225\t\225\t\225\t\225\t\225\000\238\t\225\t\225\007~\t\225\t\225\002\250\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\225\t\001\004\186\t\225\t\225\t\225\t\225\t\193\t\193\003j\003n\006\214\t\193\tv\t\193\t\193\005\254\t\193\t\193\t\193\t\193\002\162\t\193\t\193\016\190\t\193\t\193\t\193\017v\t\193\t\193\t\193\t\193\tz\t\193\011>\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\006*\006\142\006\166\t\193\002\250\t\193\t\193\t\193\t\193\t\193\018\026\t\193\t\193\004:\t\193\012\178\t\193\t\193\t\193\002\238\012\018\t\193\t\193\t\193\t\193\t\193\t\193\t\193\018&\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\012\022\t\193\t\193\b\189\t\193\t\193\002\254\012^\001\002\001\190\t\193\t\193\t\193\t\193\t\193\004F\t\193\t\193\t\193\t\193\t\193\006U\t\193\t\193\011F\t\193\t\193\012b\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\006U\000\238\t\193\t\193\t\193\t\193\t\201\t\201\003j\017\206\002r\t\201\012.\t\201\t\201\006\146\t\201\t\201\t\201\t\201\007\130\t\201\t\201\017\226\t\201\t\201\t\201\tv\t\201\t\201\t\201\t\201\001v\t\201\0122\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\011\174\025\222\b\189\t\201\012\174\t\201\t\201\t\201\t\201\t\201\000\238\t\201\t\201\002r\t\201\012\198\t\201\t\201\t\201\001\222\003\242\t\201\t\201\t\201\t\201\t\201\t\201\t\201\004A\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\0112\t\201\t\201\003\246\t\201\t\201\006\174\016*\001\002\001\190\t\201\t\201\t\201\t\201\t\201\015n\t\201\t\201\t\201\t\201\t\201\006]\t\201\t\201\004\213\t\201\t\201\012>\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\006]\000\238\t\201\t\201\t\201\t\201\n\001\n\001\012\230\012B\002\246\n\001\012v\n\001\n\001\000\238\n\001\n\001\n\001\n\001\n\246\n\001\n\001\000\238\n\001\n\001\n\001\012\018\n\001\n\001\n\001\n\001\001\134\n\001\012z\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\004\182\006\162\011N\n\001\012\242\n\001\n\001\n\001\n\001\n\001\011r\n\001\n\001\019\"\n\001\012\218\n\001\n\001\n\001\006\226\012^\n\001\n\001\n\001\n\001\n\001\n\001\n\001\021\186\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\rJ\n\001\n\001\n\178\n\001\n\001\n\190\014\022\007\130\022\002\n\001\n\001\n\001\n\001\n\001\018\162\n\001\n\001\n\001\n\001\n\001\006e\n\001\n\001\n\178\n\001\n\001\n\190\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\006e\011\234\n\001\n\001\n\001\n\001\t\241\t\241\027*\001\222\014\030\t\241\004\186\t\241\t\241\000\238\t\241\t\241\t\241\t\241\001\206\t\241\t\241\012\194\t\241\t\241\t\241\0142\t\241\t\241\t\241\t\241\001\150\t\241\012.\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\005\n\018\190\014F\t\241\0146\t\241\t\241\t\241\t\241\t\241\014j\t\241\t\241\r\006\t\241\012\246\t\241\t\241\t\241\002~\005\026\t\241\t\241\t\241\t\241\t\241\t\241\t\241\004A\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\b\217\t\241\t\241\rj\t\241\t\241\005\221\018\182\002\162\026\026\t\241\t\241\t\241\t\241\t\241\005\225\t\241\t\241\t\241\t\241\t\241\b\230\t\241\t\241\t\006\t\241\t\241\tN\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\000\238\000\238\t\241\t\241\t\241\t\241\t\233\t\233\001\002\001\190\014n\t\233\b\237\t\233\t\233\019:\t\233\t\233\t\233\t\233\017\214\t\233\t\233\012v\t\233\t\233\t\233\001\206\t\233\t\233\t\233\t\233\004\186\t\233\014J\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\005\"\b\217\rV\t\233\rn\t\233\t\233\t\233\t\233\t\233\014\198\t\233\t\233\022\250\t\233\r\n\t\233\t\233\t\233\000\238\012>\t\233\t\233\t\233\t\233\t\233\t\233\t\233\023\146\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\002\250\t\233\t\233\r\026\t\233\t\233\018\234\014\242\023\150\017B\t\233\t\233\t\233\t\233\t\233\019B\t\233\t\233\t\233\t\233\t\233\011>\t\233\t\233\tV\t\233\t\233\014Z\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\t\233\001\002\001\190\t\233\t\233\t\233\t\233\t\249\t\249\014^\014\162\b!\t\249\004\186\t\249\t\249\000\238\t\249\t\249\t\249\t\249\014\210\t\249\t\249\014\202\t\249\t\249\t\249\tf\t\249\t\249\t\249\t\249\014\166\t\249\014\254\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\014\214\021\230\019\130\t\249\014\246\t\249\t\249\t\249\t\249\t\249\015\154\t\249\t\249\015\002\t\249\r\030\t\249\t\249\t\249\018\226\011>\t\249\t\249\t\249\t\249\t\249\t\249\t\249\026\022\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\b%\t\249\t\249\015\170\t\249\t\249\005\213\003}\002\253\019\150\t\249\t\249\t\249\t\249\t\249\n\158\t\249\t\249\t\249\t\249\t\249\018z\t\249\t\249\n\214\t\249\t\249\019.\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\t\249\019f\n\250\t\249\t\249\t\249\t\249\nI\nI\007\241\007R\011*\nI\018\254\nI\nI\023\018\nI\nI\nI\nI\023\006\nI\nI\007R\nI\nI\nI\011Z\nI\nI\nI\nI\026&\nI\024\246\nI\nI\nI\nI\nI\nI\nI\nI\007R\022r\021\222\nI\000\238\nI\nI\nI\nI\nI\r\005\nI\nI\000\238\nI\r*\nI\nI\nI\019\154\012\142\nI\nI\nI\nI\nI\nI\nI\022\"\nI\nI\nI\nI\nI\nI\nI\nI\nI\nI\nI\022j\nI\nI\022B\nI\nI\b\025\001\206\023.\b\021\nI\nI\nI\nI\nI\019B\nI\nI\nI\nI\nI\r\017\nI\nI\004&\nI\nI\023f\nI\nI\nI\nI\nI\nI\nI\nI\nI\nI\nI\nI\nI\000\238\001\206\nI\nI\nI\nI\003\157\003\157\025\170\007R\023\210\003\157\n\134\003\157\003\157\000\238\003\157\003\157\003\157\003\157\rb\003\157\003\157\024\250\003\157\003\157\003\157\rz\003\157\003\157\003\157\003\157\027o\003\157\027&\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\026\142\r\130\022\162\003\157\002\006\003\157\003\157\003\157\003\157\003\157\024\178\003\157\003\157\004Y\003\157\r\150\003\157\003\157\003\157\024\230\r\198\003\157\003\157\003\157\003\157\003\157\003\157\003\157\r\242\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\024\218\t2\tb\026\186\003\157\003\157\001\222\015J\015r\003\226\003\157\003\157\003\157\003\157\003\157\002\198\003\157\003\157\003\157\003\157\t:\023\214\tj\003\157\015\142\003\157\003\157\015\146\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\003\157\000\238\003\157\003\157\003\157\003\157\003\157\001\237\001\237\015\186\015\206\015\230\001\237\015\250\002\162\001\237\016&\002f\001\237\tJ\001\237\016:\002\218\001\237\024\182\001\237\001\237\001\237\017:\001\237\001\237\001\237\001\210\024\234\tR\017F\002\222\001\237\001\237\001\237\001\237\001\237\tZ\001\237\005\250\017\234\018\002\002\226\018\138\001\237\001\237\001\237\001\237\001\237\018\142\003\022\001\190\026\190\001\237\018\198\001\237\001\237\002\150\018\202\018\242\003\030\001\237\001\237\001\237\007\254\b\002\b\014\018\246\012J\005Z\001\237\001\237\001\237\001\237\001\237\001\237\001\237\001\237\001\237\019\030\t2\tb\019\202\001\237\001\237\019\206\019\242\019\246\020\006\005f\005j\001\237\001\237\001\237\020\022\001\237\001\237\001\237\001\237\012R\020\"\012\162\001\237\020V\001\237\001\237\020Z\001\237\001\237\001\237\001\237\001\237\001\237\005n\b\022\001\237\001\237\001\237\b.\004V\020\166\020\206\001\237\001\237\001\237\001\237\n1\n1\020\210\020\226\0212\n1\021R\002\162\n1\021\146\002f\n1\n1\n1\021\182\002\218\n1\021\198\n1\n1\n1\021\238\n1\n1\n1\001\210\021\242\n1\021\254\002\222\n1\n1\n1\n1\n1\n1\n1\022\014\022*\022:\002\226\022N\n1\n1\n1\n1\n1\022z\003\022\001\190\022~\n1\022\138\n1\n1\002\150\022\154\022\174\003\030\n1\n1\n1\007\254\b\002\b\014\023\162\n1\005Z\n1\n1\n1\n1\n1\n1\n1\n1\n1\023\250\n1\n1\024\"\n1\n1\024\138\024\154\0256\025>\005f\005j\n1\n1\n1\025N\n1\n1\n1\n1\n1\025Z\n1\n1\025\190\n1\n1\025\210\n1\n1\n1\n1\n1\n1\005n\b\022\n1\n1\n1\b.\004V\026\002\026\n\n1\n1\n1\n1\n-\n-\026F\026n\026\166\n-\026\214\002\162\n-\026\226\002f\n-\n-\n-\026\234\002\218\n-\026\243\n-\n-\n-\027\003\n-\n-\n-\001\210\027\022\n-\0272\002\222\n-\n-\n-\n-\n-\n-\n-\027O\027_\027{\002\226\027\175\n-\n-\n-\n-\n-\027\203\003\022\001\190\027\214\n-\028\011\n-\n-\002\150\028\031\028'\003\030\n-\n-\n-\007\254\b\002\b\014\028c\n-\005Z\n-\n-\n-\n-\n-\n-\n-\n-\n-\028k\n-\n-\000\000\n-\n-\000\000\000\000\000\000\000\000\005f\005j\n-\n-\n-\000\000\n-\n-\n-\n-\n-\000\000\n-\n-\000\000\n-\n-\000\000\n-\n-\n-\n-\n-\n-\005n\b\022\n-\n-\n-\b.\004V\000\000\000\000\n-\n-\n-\n-\0029\0029\000\000\000\000\000\000\0029\000\000\002\162\0029\000\000\002f\0029\tJ\0029\000\000\002\218\0029\000\000\0029\0029\0029\000\000\0029\0029\0029\001\210\002\225\tR\000\000\002\222\0029\0029\0029\0029\0029\tZ\0029\000\000\000\000\000\000\002\226\004A\0029\0029\0029\0029\0029\000\000\003\022\001\190\000\000\0029\000\n\0029\0029\002\150\000\000\000\000\003\030\0029\0029\0029\007\254\b\002\b\014\000\000\012J\005Z\0029\0029\0029\0029\0029\0029\0029\0029\0029\000\000\004\173\0029\002\225\0029\0029\004A\006f\002\162\004A\005f\005j\0029\0029\0029\000\000\0029\0029\0029\0029\000\000\000\238\004A\0029\004\173\0029\0029\004A\0029\0029\0029\0029\0029\0029\005n\b\022\0029\0029\0029\b.\004V\000\000\004A\0029\0029\0029\0029\004A\004A\004A\002\238\004A\004A\004A\004A\004A\004A\004A\017\158\004A\000\238\004A\004A\000\000\004A\004A\004A\000\000\004A\004A\004A\004A\004A\004A\004A\004A\004A\000\238\004A\004A\000\000\000\000\004A\004A\000\238\004A\004A\004A\004A\004A\000\238\004A\004A\004A\004A\004A\004A\004A\004A\000\238\004A\004A\004A\004A\004A\004A\004A\004A\000\238\004A\004A\004A\004A\004A\004A\004A\004A\b\189\0042\004A\000\000\000\000\004A\004A\004A\000\238\004A\000\n\000\000\004A\004A\004A\004A\004A\004A\004A\004A\004A\000\000\021\170\004A\004A\002\225\002\225\007J\004A\004&\006\233\000\000\004A\004A\000\000\007R\000\000\022\026\002\225\000\238\004A\004A\004A\007V\000\000\004A\004A\004A\004A\006\233\000\161\004A\000\161\006\233\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\000\000\161\022\206\000\161\000\161\000\000\000\161\000\161\000\000\000\000\000\161\000\161\000\000\000\161\000\161\000\161\000\161\000\000\000\161\0046\000\161\000\161\b\189\000\000\000\161\000\161\005\141\000\161\000\161\000\161\000\238\000\161\b\241\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\000\bn\000\161\000\161\000\000\000\000\000\161\000\161\002\006\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\002\n\006\233\000\000\015f\t\029\000\161\002f\000\161\001\210\000\161\005\141\002\162\000\000\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\161\000\000\000\000\000\000\000\161\003~\017\210\t\029\005\141\000\222\000\000\006\230\001\222\000\161\000\000\002\198\000\000\014z\002\150\000\161\000\161\000\161\000\161\000\000\015j\000\161\000\161\000\161\000\161\002)\002)\004Y\000\000\002\238\002)\000\000\002\162\002)\015v\002f\002)\001b\002)\000\000\002\218\002)\006\234\002)\002)\002)\000\000\002)\002)\002)\001\210\001z\000\000\001\138\002\222\002)\002)\002)\002)\002)\005j\002)\000\000\000\000\000\000\002\226\b\169\002)\002)\002)\002)\002)\004Y\003\022\b\018\000\000\002)\000\000\002)\002)\002\150\000\000\006\006\003\030\002)\002)\002)\007\254\b\002\b\014\t2\tb\005Z\002)\002)\002)\002)\002)\002)\002)\002)\002)\006\n\t2\tb\b\169\002)\002)\000\000\t:\007\002\tj\005f\005j\002)\002)\002)\000\000\002)\002)\002)\002)\t:\000\000\tj\002)\b\169\002)\002)\016j\002)\002)\002)\002)\002)\002)\005n\b\022\002)\002)\002)\b.\004V\000\238\000\000\002)\002)\002)\002)\002E\002E\000\000\007n\000\000\002E\000\000\000\000\002E\000\000\b\169\002E\000\000\002E\004\226\000\000\002E\b\169\002E\002E\002E\000\238\002E\002E\002E\000\000\027\187\000\000\002\225\002\225\002E\002E\002E\002E\002E\000\000\002E\000\000\006\014\004\169\000\000\005\206\002E\002E\002E\002E\002E\000\000\006\026\000\000\000\000\002E\006&\002E\002E\000\n\000\000\000\000\006b\002E\002E\002E\004\169\000\000\000\000\006\213\016n\000\000\002E\002E\002E\002E\002E\002E\002E\002E\002E\000\000\t2\tb\000\000\002E\002E\002\225\006j\000\000\002\162\000\000\006\213\002E\002E\002E\000\000\002E\002E\002E\002E\t:\002\162\tj\002E\002f\002E\002E\001\210\002E\002E\002E\002E\002E\002E\b\165\000\000\002E\002E\002E\000\000\021\154\000\000\000\000\002E\002E\002E\002E\002A\002A\000\000\022\214\002\238\002A\022\218\002\250\002A\000\000\002\150\002A\000\000\002A\000\000\017j\002A\023\n\002A\002A\002A\t>\002A\002A\002A\012\n\b\165\000\000\000\000\015v\002A\002A\002A\002A\002A\rN\002A\rZ\000\000\012&\023\026\0126\002A\002A\002A\002A\002A\b\165\bJ\001\190\001*\002A\000\000\002A\002A\005j\002\225\002\225\014:\002A\002A\002A\014N\014b\014r\000\000\000\000\000\000\002A\002A\002A\002A\002A\002A\002A\002A\002A\000\000\t2\tb\b\165\002A\002A\000\n\004\226\000\000\001\206\b\165\000\000\002A\002A\002A\000\000\002A\002A\002A\002A\t:\000\000\tj\002A\000\000\002A\002A\001\210\002A\002A\002A\002A\002A\002A\002\225\000\000\002A\002A\002A\000\000\018\146\000\000\000\000\002A\002A\002A\002A\002-\002-\000\000\000\000\002~\002-\019\026\002\250\002-\000\000\002\150\002-\000\000\002-\000\000\000\000\002-\0192\002-\002-\002-\012V\002-\002-\002-\002\225\002\225\016\150\000\000\000\000\002-\002-\002-\002-\002-\012n\002-\012\134\000\000\000\000\002\225\012\234\002-\002-\002-\002-\002-\000\000\bJ\014\178\000\000\002-\000\n\002-\002-\012\254\000\000\r\018\014:\002-\002-\002-\014N\014b\014r\t\025\000\000\000\000\002-\002-\002-\002-\002-\002-\002-\002-\002-\000\000\t2\tb\002\225\002-\002-\000\000\014\146\002\225\000\000\000\238\t\025\002-\002-\002-\000\000\002-\002-\002-\002-\t:\000\000\tj\002-\000\000\002-\002-\000\000\002-\002-\002-\002-\002-\002-\000\n\000\000\002-\002-\002-\000\000\t\030\000\000\000\000\002-\002-\002-\002-\002=\002=\000\000\002\225\000\000\002=\012}\006\014\002=\000\000\005\206\002=\000\000\002=\000\000\002\225\002=\006\026\002=\002=\002=\006&\002=\002=\002=\012}\012}\000\000\000\000\012}\002=\002=\002=\002=\002=\000\000\002=\b\021\000\000\000\000\b\021\000\000\002=\002=\002=\002=\002=\000\000\000\000\000\000\000\000\002=\000\000\002=\002=\000\000\000\000\000\000\022\"\002=\002=\002=\000\000\000\000\000\000\000\000\000\000\000\238\002=\002=\002=\002=\002=\002=\002=\002=\002=\000\000\b\021\002=\000\000\002=\002=\000\000\000\000\000\000\000\000\000\000\000\000\002=\002=\002=\b\021\002=\002=\002=\002=\012}\000\000\004\253\002=\000\000\002=\002=\002\225\t\130\002=\002=\002=\002=\002=\004\253\n\202\002=\002=\002=\000\000\000\000\b\021\000\000\002=\002=\002=\002=\t%\t%\000\000\000\000\000\000\t%\000\000\000\000\t%\000\n\000\000\t%\000\000\t%\000\000\000\000\t\174\004\253\t%\t\210\t%\b\021\t%\t%\t%\002\225\000\000\000\000\000\000\017\006\t\230\t\254\n\006\t\238\n\014\000\000\t%\002\225\002\225\000\000\000\000\000\000\t%\t%\n\022\n\030\t%\004\253\007\245\000\000\004\253\t%\000\000\n&\t%\000\000\000\000\000\000\000\000\t%\t%\000\238\000\000\000\000\000\000\000\000\000\000\002\218\t%\t%\t\182\t\246\n.\n6\nF\t%\t%\002\138\012\181\t%\000\000\t%\nN\000\000\003>\000\000\000\000\000\238\000\000\t%\t%\nV\000\000\t%\t%\t%\t%\003J\012\181\000\000\t%\000\000\t%\t%\002\030\nv\t%\n~\n>\t%\t%\000\000\000\000\t%\n^\t%\000\000\002&\000\000\005Z\t%\t%\nf\nn\002q\002q\000\000\000\000\000\000\002q\012\133\006\014\002q\000\000\005\206\002q\000\000\002q\000\000\005f\002q\006\026\002q\002q\002q\006&\002q\002q\002q\012\133\012\133\000\000\000\000\012\133\002q\002q\002q\002q\002q\000\000\002q\015f\000\000\005n\002f\000\000\002q\002q\002q\002q\002q\000\000\000\000\000\000\000\000\002q\000\000\002q\002q\000\000\000\000\000\000\000\000\002q\002q\002q\000\000\000\000\000\000\000\000\000\000\000\238\002q\002q\t\182\002q\002q\002q\002q\002q\002q\000\000\015j\002q\000\000\002q\002q\000\000\000\000\000\000\000\000\000\000\000\000\002q\002q\002q\015v\002q\002q\002q\002q\012\133\000\000\001\206\002q\000\000\002q\002q\000\000\002q\002q\002q\002q\002q\002q\025\242\000\000\002q\002q\002q\000\000\000\000\005j\000\000\002q\002q\002q\002q\002Y\002Y\000\000\000\000\000\000\002Y\000\000\002\162\002Y\000\000\000\000\002Y\000\000\002Y\003\142\000\000\002Y\002~\002Y\002Y\002Y\025b\002Y\002Y\002Y\001\210\000\000\000\000\000\000\000\000\002Y\002Y\002Y\002Y\002Y\000\000\002Y\015f\000\000\000\000\002f\000\000\002Y\002Y\002Y\002Y\002Y\004~\003\174\000\000\004\217\002Y\000\000\002Y\002Y\002\150\000\000\000\000\000\000\002Y\002Y\002Y\000\000\000\000\000\000\000\000\000\000\000\000\002Y\002Y\t\182\002Y\002Y\002Y\002Y\002Y\002Y\000\000\015j\002Y\000\000\002Y\002Y\006\206\000\000\000\000\000\000\000\000\000\000\002Y\002Y\002Y\015v\002Y\002Y\002Y\002Y\000\000\000\000\000\000\002Y\000\000\002Y\002Y\000\000\002Y\002Y\002Y\002Y\002Y\002Y\012\129\000\000\002Y\002Y\002Y\000\000\000\000\005j\000\000\002Y\002Y\002Y\002Y\002e\002e\000\000\000\000\000\000\002e\012\129\012\129\002e\000\000\012\129\002e\000\000\002e\000\000\000\000\t\174\000\000\002e\002e\002e\020\254\002e\002e\002e\000\000\000\000\000\000\000\000\000\000\002e\002e\002e\t\238\002e\000\000\002e\000\000\000\000\000\000\000\000\000\000\002e\002e\002e\002e\002e\000\000\000\238\000\000\000\000\002e\000\000\002e\002e\000\000\000\000\000\000\000\000\002e\002e\002e\000\000\000\000\000\000\000\000\000\000\000\000\002e\002e\t\182\t\246\002e\002e\002e\002e\002e\000\000\012\129\002e\000\000\002e\002e\000\000\000\000\000\000\000\000\000\238\b\t\002e\002e\002e\b\t\002e\002e\002e\002e\000\000\000\000\000\000\002e\000\000\002e\002e\000\000\002e\002e\002e\002e\002e\002e\000\000\000\000\002e\002e\002e\000\000\011~\000\000\000\000\002e\002e\002e\002e\002u\002u\000\000\000\000\000\000\002u\b\t\011\134\002u\000\000\011\146\002u\000\000\002u\000\000\000\000\002u\011\158\002u\002u\002u\011\170\002u\002u\002u\000\000\000\000\b\t\000\000\000\000\002u\002u\002u\002u\002u\000\000\002u\000\000\000\000\000\000\000\000\000\000\002u\002u\002u\002u\002u\000\000\000\000\000\000\000\000\002u\000\000\002u\002u\000\000\000\000\000\000\000\000\002u\002u\002u\000\000\000\000\004\226\000\000\000\000\000\000\002u\002u\t\182\002u\002u\002u\002u\002u\002u\000\000\007\206\002u\000\000\002u\002u\000\000\000\000\000\000\000\000\000\238\b\005\002u\002u\002u\b\005\002u\002u\002u\002u\000\000\007\210\000\000\002u\000\000\002u\002u\000\000\002u\002u\002u\002u\002u\002u\000\000\000\000\002u\002u\002u\000\000\007\165\000\000\000\000\002u\002u\002u\002u\002U\002U\007\194\000\000\000\000\002U\b\005\007\165\002U\000\000\005\206\002U\000\000\002U\000\000\000\238\002U\007\165\002U\002U\002U\007\165\002U\002U\002U\000\000\000\000\b\005\000\000\000\000\002U\002U\002U\002U\002U\000\000\002U\000\000\000\000\006\253\000\000\000\000\002U\002U\002U\002U\002U\000\000\000\000\000\000\000\000\002U\000\000\002U\002U\000\000\000\000\000\000\006\253\002U\002U\002U\006\253\007\214\004\226\000\000\000\000\000\000\002U\002U\t\182\002U\002U\002U\002U\002U\002U\000\000\000\000\002U\000\000\002U\002U\000\000\000\000\000\000\000\000\007\189\000\000\002U\002U\002U\000\000\002U\002U\002U\002U\000\000\000\000\000\000\002U\000\000\002U\002U\000\000\002U\002U\002U\002U\002U\002U\000\000\000\000\002U\002U\002U\000\000\007\189\000\000\000\000\002U\002U\002U\002U\002a\002a\000\000\000\000\000\000\002a\005J\007\189\002a\000\000\005\206\002a\000\000\002a\000\000\000\000\t\174\007\189\002a\002a\002a\007\189\002a\002a\002a\000\000\000\000\000\000\000\000\000\000\002a\002a\002a\t\238\002a\000\000\002a\000\000\000\000\006\237\000\000\000\000\002a\002a\002a\002a\002a\000\000\000\000\000\000\000\000\002a\000\000\002a\002a\000\000\000\000\000\000\006\237\002a\002a\002a\006\237\000\000\000\000\000\000\000\000\000\000\002a\002a\t\182\t\246\002a\002a\002a\002a\002a\000\000\000\000\002a\000\000\002a\002a\000\000\000\000\000\000\000\000\000\238\000\000\002a\002a\002a\000\000\002a\002a\002a\002a\000\000\000\000\000\000\002a\000\000\002a\002a\000\000\002a\002a\002a\002a\002a\002a\000\000\000\000\002a\002a\002a\000\000\007\217\000\000\000\000\002a\002a\002a\002a\002]\002]\000\000\000\000\000\000\002]\b\n\006\014\002]\000\000\005\206\002]\000\000\002]\000\000\000\000\t\174\007\217\002]\002]\002]\007\217\002]\002]\002]\000\000\000\000\000\000\000\000\000\000\002]\002]\002]\t\238\002]\000\000\002]\000\000\000\000\000\000\000\000\000\000\002]\002]\002]\002]\002]\000\000\000\000\000\000\000\000\002]\000\000\002]\002]\000\000\000\000\000\000\000\000\002]\002]\002]\000\000\000\000\000\000\000\000\000\000\000\000\002]\002]\t\182\t\246\002]\002]\002]\002]\002]\000\000\000\000\002]\000\000\002]\002]\000\000\000\000\000\000\000\000\007\209\000\000\002]\002]\002]\000\000\002]\002]\002]\002]\000\000\000\000\000\000\002]\000\000\002]\002]\000\000\002]\002]\002]\002]\002]\002]\000\000\000\000\002]\002]\002]\000\000\007\209\000\000\000\000\002]\002]\002]\002]\002\133\002\133\000\000\000\000\000\000\002\133\000\000\011\194\002\133\000\000\007\209\002\133\000\000\002\133\000\000\000\000\t\174\007\209\002\133\002\133\002\133\007\209\002\133\002\133\002\133\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\133\000\000\000\000\000\000\000\000\000\000\002\133\002\133\n\022\n\030\002\133\000\000\000\000\000\000\000\000\002\133\000\000\n&\002\133\000\000\000\000\000\000\000\000\002\133\002\133\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\133\002\133\t\182\t\246\n.\n6\nF\002\133\002\133\000\000\000\000\002\133\000\000\002\133\nN\000\000\000\000\000\000\000\000\000\238\000\000\002\133\002\133\nV\000\000\002\133\002\133\002\133\002\133\000\000\000\000\000\000\002\133\000\000\002\133\002\133\000\000\002\133\002\133\002\133\n>\002\133\002\133\000\000\000\000\002\133\n^\002\133\000\000\007\161\000\000\000\000\002\133\002\133\nf\nn\002m\002m\000\000\000\000\000\000\002m\000\000\007\161\002m\000\000\005\206\002m\000\000\002m\000\000\000\000\t\174\007\161\002m\002m\002m\007\161\002m\002m\002m\000\000\000\000\000\000\000\000\000\000\002m\002m\002m\t\238\002m\000\000\002m\000\000\000\000\000\000\000\000\000\000\002m\002m\002m\002m\002m\000\000\000\000\000\000\000\000\002m\000\000\002m\002m\000\000\000\000\000\000\000\000\002m\002m\002m\000\000\000\000\000\000\000\000\000\000\000\000\002m\002m\t\182\t\246\002m\002m\002m\002m\002m\000\000\000\000\002m\000\000\002m\002m\000\000\000\000\000\000\000\000\000\238\000\000\002m\002m\002m\000\000\002m\002m\002m\002m\000\000\000\000\000\000\002m\000\000\002m\002m\000\000\002m\002m\002m\002m\002m\002m\000\000\000\000\002m\002m\002m\000\000\014\n\000\000\000\000\002m\002m\002m\002m\002i\002i\000\000\000\000\000\000\002i\000\000\011\134\002i\000\000\011\146\002i\000\000\002i\000\000\000\000\t\174\011\158\002i\002i\002i\011\170\002i\002i\002i\000\000\000\000\000\000\000\000\000\000\002i\002i\002i\t\238\002i\000\000\002i\000\000\000\000\000\000\000\000\000\000\002i\002i\002i\002i\002i\000\000\000\000\000\000\000\000\002i\000\000\002i\002i\000\000\000\000\000\000\000\000\002i\002i\002i\000\000\000\000\000\000\000\000\000\000\000\000\002i\002i\t\182\t\246\002i\002i\002i\002i\002i\000\000\000\000\002i\000\000\002i\002i\000\000\000\000\000\000\000\000\000\000\000\000\002i\002i\002i\000\000\002i\002i\002i\002i\000\000\000\000\000\000\002i\000\000\002i\002i\000\000\002i\002i\002i\002i\002i\002i\000\000\000\000\002i\002i\002i\000\000\000\000\000\000\000\000\002i\002i\002i\002i\002}\002}\000\000\000\000\000\000\002}\000\000\002\006\002}\000\000\002f\002}\000\000\002}\000\000\000\000\t\174\000\000\002}\002}\002}\000\000\002}\002}\002}\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\002}\000\000\002}\000\000\000\000\000\000\000\000\000\000\002}\002}\n\022\n\030\002}\000\000\027\014\001\222\000\000\002}\000\000\002}\002}\000\000\000\000\000\000\000\000\002}\002}\000\238\015v\000\000\000\000\000\000\000\000\000\000\002}\002}\t\182\t\246\n.\n6\002}\002}\002}\000\000\000\000\002}\000\000\002}\002}\000\000\000\000\000\000\000\000\000\000\005j\002}\002}\002}\000\000\002}\002}\002}\002}\000\000\000\000\000\000\002}\000\000\002}\002}\000\000\002}\002}\002}\n>\002}\002}\000\000\000\000\002}\002}\002}\000\000\000\000\000\000\000\000\002}\002}\002}\002}\002Q\002Q\000\000\000\000\000\000\002Q\000\000\002\250\002Q\000\000\000\000\002Q\000\000\002Q\000\000\000\000\t\174\000\000\002Q\002Q\002Q\000\000\002Q\002Q\002Q\000\000\000\000\000\000\000\000\000\000\002Q\002Q\002Q\t\238\002Q\000\000\002Q\000\000\000\000\000\000\000\000\000\000\002Q\002Q\002Q\002Q\002Q\000\000\005\162\000\000\000\000\002Q\000\000\002Q\002Q\000\000\000\000\000\000\003\218\002Q\002Q\002Q\0062\000\000\003\230\000\000\000\000\000\000\002Q\002Q\t\182\t\246\002Q\002Q\002Q\002Q\002Q\000\000\000\000\002Q\000\000\002Q\002Q\000\000\000\000\000\000\000\000\000\000\000\000\002Q\002Q\002Q\000\000\002Q\002Q\002Q\002Q\000\000\000\000\000\000\002Q\000\000\002Q\002Q\000\000\002Q\002Q\002Q\002Q\002Q\002Q\000\000\000\000\002Q\002Q\002Q\000\000\000\000\000\000\000\000\002Q\002Q\002Q\002Q\002M\002M\000\000\000\000\000\000\002M\000\000\002\162\002M\000\000\000\000\002M\000\000\002M\000\000\000\000\t\174\000\000\002M\002M\002M\000\000\002M\002M\002M\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\002M\000\000\002M\000\000\000\000\000\000\000\000\000\000\002M\002M\n\022\n\030\002M\000\000\tn\002\238\000\000\002M\000\000\002M\002M\000\000\000\000\000\000\000\000\002M\002M\000\238\011\226\000\000\011\242\000\000\000\000\000\000\002M\002M\t\182\t\246\n.\n6\002M\002M\002M\000\000\000\000\002M\000\000\002M\002M\000\000\000\000\000\000\000\000\000\000\000\000\002M\002M\002M\000\000\002M\002M\002M\002M\000\000\000\000\000\000\002M\000\000\002M\002M\000\000\002M\002M\002M\n>\002M\002M\000\000\000\000\002M\002M\002M\000\000\000\000\000\000\000\000\002M\002M\002M\002M\002\169\002\169\000\000\000\000\000\000\002\169\000\000\002\162\002\169\000\000\000\000\002\169\000\000\002\169\000\000\000\000\t\174\000\000\002\169\002\169\002\169\000\000\002\169\002\169\002\169\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\002\169\000\000\002\169\000\000\000\000\000\000\000\000\000\000\002\169\002\169\n\022\n\030\002\169\000\000\012\166\002\238\000\000\002\169\000\000\002\169\002\169\000\000\000\000\000\000\000\000\002\169\002\169\002\169\012\186\000\000\012\206\000\000\000\000\000\000\002\169\002\169\t\182\t\246\n.\002\169\002\169\002\169\002\169\000\000\000\000\002\169\000\000\002\169\002\169\000\000\000\000\000\000\000\000\000\000\000\000\002\169\002\169\002\169\000\000\002\169\002\169\002\169\002\169\000\000\000\000\000\000\002\169\000\000\002\169\002\169\000\000\002\169\002\169\002\169\n>\002\169\002\169\000\000\000\000\002\169\002\169\002\169\000\000\000\000\000\000\000\000\002\169\002\169\002\169\002\169\002I\002I\000\000\000\000\000\000\002I\000\000\000\000\002I\000\000\000\000\002I\000\000\002I\000\000\000\000\t\174\000\000\002I\002I\002I\000\000\002I\002I\002I\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\002I\000\000\002I\000\000\000\000\000\000\000\000\000\000\002I\002I\n\022\n\030\002I\000\000\000\000\000\000\000\000\002I\000\000\002I\002I\000\000\000\000\000\000\000\000\002I\002I\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002I\002I\t\182\t\246\n.\n6\002I\002I\002I\000\000\000\000\002I\000\000\002I\002I\000\000\000\000\000\000\000\000\000\000\000\000\002I\002I\002I\000\000\002I\002I\002I\002I\000\000\000\000\000\000\002I\000\000\002I\002I\000\000\002I\002I\002I\n>\002I\002I\000\000\000\000\002I\002I\002I\000\000\000\000\000\000\000\000\002I\002I\002I\002I\002\129\002\129\000\000\000\000\000\000\002\129\000\000\000\000\002\129\000\000\000\000\002\129\000\000\002\129\000\000\000\000\t\174\000\000\002\129\002\129\002\129\000\000\002\129\002\129\002\129\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\002\129\000\000\002\129\000\000\000\000\000\000\000\000\000\000\002\129\002\129\n\022\n\030\002\129\000\000\000\000\000\000\000\000\002\129\000\000\002\129\002\129\000\000\000\000\000\000\000\000\002\129\002\129\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\129\002\129\t\182\t\246\n.\n6\002\129\002\129\002\129\000\000\000\000\002\129\000\000\002\129\002\129\000\000\000\000\000\000\000\000\000\000\000\000\002\129\002\129\002\129\000\000\002\129\002\129\002\129\002\129\000\000\000\000\000\000\002\129\000\000\002\129\002\129\000\000\002\129\002\129\002\129\n>\002\129\002\129\000\000\000\000\002\129\002\129\002\129\000\000\000\000\000\000\000\000\002\129\002\129\002\129\002\129\002y\002y\000\000\000\000\000\000\002y\000\000\000\000\002y\000\000\000\000\002y\000\000\002y\000\000\000\000\t\174\000\000\002y\002y\002y\000\000\002y\002y\002y\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\002y\000\000\002y\000\000\000\000\000\000\000\000\000\000\002y\002y\n\022\n\030\002y\000\000\000\000\000\000\000\000\002y\000\000\002y\002y\000\000\000\000\000\000\000\000\002y\002y\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002y\002y\t\182\t\246\n.\n6\002y\002y\002y\000\000\000\000\002y\000\000\002y\002y\000\000\000\000\000\000\000\000\000\000\000\000\002y\002y\002y\000\000\002y\002y\002y\002y\000\000\000\000\000\000\002y\000\000\002y\002y\000\000\002y\002y\002y\n>\002y\002y\000\000\000\000\002y\002y\002y\000\000\000\000\000\000\000\000\002y\002y\002y\002y\002\137\002\137\000\000\000\000\000\000\002\137\000\000\000\000\002\137\000\000\000\000\002\137\000\000\002\137\000\000\000\000\t\174\000\000\002\137\002\137\002\137\000\000\002\137\002\137\002\137\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\137\000\000\000\000\000\000\000\000\000\000\002\137\002\137\n\022\n\030\002\137\000\000\000\000\000\000\000\000\002\137\000\000\n&\002\137\000\000\000\000\000\000\000\000\002\137\002\137\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\137\002\137\t\182\t\246\n.\n6\nF\002\137\002\137\000\000\000\000\002\137\000\000\002\137\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\137\002\137\nV\000\000\002\137\002\137\002\137\002\137\000\000\000\000\000\000\002\137\000\000\002\137\002\137\000\000\002\137\002\137\002\137\n>\002\137\002\137\000\000\000\000\002\137\n^\002\137\000\000\000\000\000\000\000\000\002\137\002\137\nf\nn\002\141\002\141\000\000\000\000\000\000\002\141\000\000\000\000\002\141\000\000\000\000\002\141\000\000\002\141\000\000\000\000\t\174\000\000\002\141\002\141\002\141\000\000\002\141\002\141\002\141\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\002\141\000\000\002\141\000\000\000\000\000\000\000\000\000\000\002\141\002\141\n\022\n\030\002\141\000\000\000\000\000\000\000\000\002\141\000\000\n&\002\141\000\000\000\000\000\000\000\000\002\141\002\141\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\141\002\141\t\182\t\246\n.\n6\nF\002\141\002\141\000\000\000\000\002\141\000\000\002\141\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\141\002\141\nV\000\000\002\141\002\141\002\141\002\141\000\000\000\000\000\000\002\141\000\000\002\141\002\141\000\000\002\141\002\141\002\141\n>\002\141\002\141\000\000\000\000\002\141\002\141\002\141\000\000\000\000\000\000\000\000\002\141\002\141\nf\nn\002\145\002\145\000\000\000\000\000\000\002\145\000\000\000\000\002\145\000\000\000\000\002\145\000\000\002\145\000\000\000\000\t\174\000\000\002\145\002\145\002\145\000\000\002\145\002\145\002\145\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\002\145\000\000\002\145\000\000\000\000\000\000\000\000\000\000\002\145\002\145\n\022\n\030\002\145\000\000\000\000\000\000\000\000\002\145\000\000\n&\002\145\000\000\000\000\000\000\000\000\002\145\002\145\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\145\002\145\t\182\t\246\n.\n6\nF\002\145\002\145\000\000\000\000\002\145\000\000\002\145\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\145\002\145\nV\000\000\002\145\002\145\002\145\002\145\000\000\000\000\000\000\002\145\000\000\002\145\002\145\000\000\002\145\002\145\002\145\n>\002\145\002\145\000\000\000\000\002\145\002\145\002\145\000\000\000\000\000\000\000\000\002\145\002\145\nf\nn\b\225\b\225\000\000\000\000\000\000\b\225\000\000\000\000\b\225\000\000\000\000\b\225\000\000\b\225\000\000\000\000\t\174\000\000\b\225\b\225\b\225\000\000\b\225\b\225\b\225\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\b\225\000\000\000\000\000\000\000\000\000\000\b\225\b\225\n\022\n\030\b\225\000\000\000\000\000\000\000\000\b\225\000\000\n&\b\225\000\000\000\000\000\000\000\000\b\225\b\225\000\238\000\000\000\000\000\000\000\000\000\000\000\000\b\225\b\225\t\182\t\246\n.\n6\nF\b\225\b\225\000\000\000\000\b\225\000\000\b\225\nN\000\000\000\000\000\000\000\000\000\000\000\000\b\225\b\225\nV\000\000\b\225\b\225\b\225\b\225\000\000\000\000\000\000\b\225\000\000\b\225\b\225\000\000\b\225\b\225\b\225\n>\b\225\b\225\000\000\000\000\b\225\n^\b\225\000\000\000\000\000\000\000\000\b\225\b\225\nf\nn\002\149\002\149\000\000\000\000\000\000\002\149\000\000\000\000\002\149\000\000\000\000\002\149\000\000\002\149\000\000\000\000\t\174\000\000\002\149\002\149\002\149\000\000\002\149\002\149\002\149\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\149\000\000\000\000\000\000\000\000\000\000\002\149\002\149\n\022\n\030\002\149\000\000\000\000\000\000\000\000\002\149\000\000\n&\002\149\000\000\000\000\000\000\000\000\002\149\002\149\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\149\002\149\t\182\t\246\n.\n6\nF\002\149\002\149\000\000\000\000\002\149\000\000\002\149\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\149\002\149\nV\000\000\002\149\002\149\002\149\002\149\000\000\000\000\000\000\002\149\000\000\002\149\002\149\000\000\nv\002\149\n~\n>\002\149\002\149\000\000\000\000\002\149\n^\002\149\000\000\000\000\000\000\000\000\002\149\002\149\nf\nn\b\221\b\221\000\000\000\000\000\000\b\221\000\000\000\000\b\221\000\000\000\000\b\221\000\000\b\221\000\000\000\000\t\174\000\000\b\221\b\221\b\221\000\000\b\221\b\221\b\221\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\b\221\000\000\000\000\000\000\000\000\000\000\b\221\b\221\n\022\n\030\b\221\000\000\000\000\000\000\000\000\b\221\000\000\n&\b\221\000\000\000\000\000\000\000\000\b\221\b\221\000\238\000\000\000\000\000\000\000\000\000\000\000\000\b\221\b\221\t\182\t\246\n.\n6\nF\b\221\b\221\000\000\000\000\b\221\000\000\b\221\nN\000\000\000\000\000\000\000\000\000\000\000\000\b\221\b\221\nV\000\000\b\221\b\221\b\221\b\221\000\000\000\000\000\000\b\221\000\000\b\221\b\221\000\000\b\221\b\221\b\221\n>\b\221\b\221\000\000\000\000\b\221\n^\b\221\000\000\000\000\000\000\000\000\b\221\b\221\nf\nn\002\197\002\197\000\000\000\000\000\000\002\197\000\000\000\000\002\197\000\000\000\000\002\197\000\000\002\197\000\000\000\000\t\174\000\000\002\197\002\197\002\197\000\000\002\197\002\197\002\197\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\197\000\000\000\000\000\000\000\000\000\000\002\197\002\197\n\022\n\030\002\197\000\000\000\000\000\000\000\000\002\197\000\000\n&\002\197\000\000\000\000\000\000\000\000\002\197\002\197\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\197\002\197\t\182\t\246\n.\n6\nF\002\197\002\197\000\000\000\000\002\197\000\000\002\197\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\197\002\197\nV\000\000\002\197\002\197\002\197\002\197\000\000\000\000\000\000\002\197\000\000\002\197\002\197\000\000\nv\002\197\n~\n>\002\197\002\197\000\000\000\000\002\197\n^\002\197\000\000\000\000\000\000\000\000\002\197\002\197\nf\nn\002\193\002\193\000\000\000\000\000\000\002\193\000\000\000\000\002\193\000\000\000\000\002\193\000\000\002\193\000\000\000\000\t\174\000\000\002\193\002\193\002\193\000\000\002\193\002\193\002\193\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\193\000\000\000\000\000\000\000\000\000\000\002\193\002\193\n\022\n\030\002\193\000\000\000\000\000\000\000\000\002\193\000\000\n&\002\193\000\000\000\000\000\000\000\000\002\193\002\193\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\193\002\193\t\182\t\246\n.\n6\nF\002\193\002\193\000\000\000\000\002\193\000\000\002\193\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\193\002\193\nV\000\000\002\193\002\193\002\193\002\193\000\000\000\000\000\000\002\193\000\000\002\193\002\193\000\000\nv\002\193\n~\n>\002\193\002\193\000\000\000\000\002\193\n^\002\193\000\000\000\000\000\000\000\000\002\193\002\193\nf\nn\002\201\002\201\000\000\000\000\000\000\002\201\000\000\000\000\002\201\000\000\000\000\002\201\000\000\002\201\000\000\000\000\t\174\000\000\002\201\002\201\002\201\000\000\002\201\002\201\002\201\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\201\000\000\000\000\000\000\000\000\000\000\002\201\002\201\n\022\n\030\002\201\000\000\000\000\000\000\000\000\002\201\000\000\n&\002\201\000\000\000\000\000\000\000\000\002\201\002\201\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\201\002\201\t\182\t\246\n.\n6\nF\002\201\002\201\000\000\000\000\002\201\000\000\002\201\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\201\002\201\nV\000\000\002\201\002\201\002\201\002\201\000\000\000\000\000\000\002\201\000\000\002\201\002\201\000\000\nv\002\201\n~\n>\002\201\002\201\000\000\000\000\002\201\n^\002\201\000\000\000\000\000\000\000\000\002\201\002\201\nf\nn\002\181\002\181\000\000\000\000\000\000\002\181\000\000\000\000\002\181\000\000\000\000\002\181\000\000\002\181\000\000\000\000\t\174\000\000\002\181\002\181\002\181\000\000\002\181\002\181\002\181\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\181\000\000\000\000\000\000\000\000\000\000\002\181\002\181\n\022\n\030\002\181\000\000\000\000\000\000\000\000\002\181\000\000\n&\002\181\000\000\000\000\000\000\000\000\002\181\002\181\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\181\002\181\t\182\t\246\n.\n6\nF\002\181\002\181\000\000\000\000\002\181\000\000\002\181\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\181\002\181\nV\000\000\002\181\002\181\002\181\002\181\000\000\000\000\000\000\002\181\000\000\002\181\002\181\000\000\nv\002\181\n~\n>\002\181\002\181\000\000\000\000\002\181\n^\002\181\000\000\000\000\000\000\000\000\002\181\002\181\nf\nn\002\185\002\185\000\000\000\000\000\000\002\185\000\000\000\000\002\185\000\000\000\000\002\185\000\000\002\185\000\000\000\000\t\174\000\000\002\185\002\185\002\185\000\000\002\185\002\185\002\185\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\185\000\000\000\000\000\000\000\000\000\000\002\185\002\185\n\022\n\030\002\185\000\000\000\000\000\000\000\000\002\185\000\000\n&\002\185\000\000\000\000\000\000\000\000\002\185\002\185\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\185\002\185\t\182\t\246\n.\n6\nF\002\185\002\185\000\000\000\000\002\185\000\000\002\185\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\185\002\185\nV\000\000\002\185\002\185\002\185\002\185\000\000\000\000\000\000\002\185\000\000\002\185\002\185\000\000\nv\002\185\n~\n>\002\185\002\185\000\000\000\000\002\185\n^\002\185\000\000\000\000\000\000\000\000\002\185\002\185\nf\nn\002\189\002\189\000\000\000\000\000\000\002\189\000\000\000\000\002\189\000\000\000\000\002\189\000\000\002\189\000\000\000\000\t\174\000\000\002\189\002\189\002\189\000\000\002\189\002\189\002\189\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\189\000\000\000\000\000\000\000\000\000\000\002\189\002\189\n\022\n\030\002\189\000\000\000\000\000\000\000\000\002\189\000\000\n&\002\189\000\000\000\000\000\000\000\000\002\189\002\189\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\189\002\189\t\182\t\246\n.\n6\nF\002\189\002\189\000\000\000\000\002\189\000\000\002\189\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\189\002\189\nV\000\000\002\189\002\189\002\189\002\189\000\000\000\000\000\000\002\189\000\000\002\189\002\189\000\000\nv\002\189\n~\n>\002\189\002\189\000\000\000\000\002\189\n^\002\189\000\000\000\000\000\000\000\000\002\189\002\189\nf\nn\002\209\002\209\000\000\000\000\000\000\002\209\000\000\000\000\002\209\000\000\000\000\002\209\000\000\002\209\000\000\000\000\t\174\000\000\002\209\002\209\002\209\000\000\002\209\002\209\002\209\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\209\000\000\000\000\000\000\000\000\000\000\002\209\002\209\n\022\n\030\002\209\000\000\000\000\000\000\000\000\002\209\000\000\n&\002\209\000\000\000\000\000\000\000\000\002\209\002\209\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\209\002\209\t\182\t\246\n.\n6\nF\002\209\002\209\000\000\000\000\002\209\000\000\002\209\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\209\002\209\nV\000\000\002\209\002\209\002\209\002\209\000\000\000\000\000\000\002\209\000\000\002\209\002\209\000\000\nv\002\209\n~\n>\002\209\002\209\000\000\000\000\002\209\n^\002\209\000\000\000\000\000\000\000\000\002\209\002\209\nf\nn\002\205\002\205\000\000\000\000\000\000\002\205\000\000\000\000\002\205\000\000\000\000\002\205\000\000\002\205\000\000\000\000\t\174\000\000\002\205\002\205\002\205\000\000\002\205\002\205\002\205\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\205\000\000\000\000\000\000\000\000\000\000\002\205\002\205\n\022\n\030\002\205\000\000\000\000\000\000\000\000\002\205\000\000\n&\002\205\000\000\000\000\000\000\000\000\002\205\002\205\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\205\002\205\t\182\t\246\n.\n6\nF\002\205\002\205\000\000\000\000\002\205\000\000\002\205\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\205\002\205\nV\000\000\002\205\002\205\002\205\002\205\000\000\000\000\000\000\002\205\000\000\002\205\002\205\000\000\nv\002\205\n~\n>\002\205\002\205\000\000\000\000\002\205\n^\002\205\000\000\000\000\000\000\000\000\002\205\002\205\nf\nn\002\213\002\213\000\000\000\000\000\000\002\213\000\000\000\000\002\213\000\000\000\000\002\213\000\000\002\213\000\000\000\000\t\174\000\000\002\213\002\213\002\213\000\000\002\213\002\213\002\213\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\213\000\000\000\000\000\000\000\000\000\000\002\213\002\213\n\022\n\030\002\213\000\000\000\000\000\000\000\000\002\213\000\000\n&\002\213\000\000\000\000\000\000\000\000\002\213\002\213\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\213\002\213\t\182\t\246\n.\n6\nF\002\213\002\213\000\000\000\000\002\213\000\000\002\213\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\213\002\213\nV\000\000\002\213\002\213\002\213\002\213\000\000\000\000\000\000\002\213\000\000\002\213\002\213\000\000\nv\002\213\n~\n>\002\213\002\213\000\000\000\000\002\213\n^\002\213\000\000\000\000\000\000\000\000\002\213\002\213\nf\nn\002\177\002\177\000\000\000\000\000\000\002\177\000\000\000\000\002\177\000\000\000\000\002\177\000\000\002\177\000\000\000\000\t\174\000\000\002\177\002\177\002\177\000\000\002\177\002\177\002\177\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\177\000\000\000\000\000\000\000\000\000\000\002\177\002\177\n\022\n\030\002\177\000\000\000\000\000\000\000\000\002\177\000\000\n&\002\177\000\000\000\000\000\000\000\000\002\177\002\177\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\177\002\177\t\182\t\246\n.\n6\nF\002\177\002\177\000\000\000\000\002\177\000\000\002\177\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\177\002\177\nV\000\000\002\177\002\177\002\177\002\177\000\000\000\000\000\000\002\177\000\000\002\177\002\177\000\000\nv\002\177\n~\n>\002\177\002\177\000\000\000\000\002\177\n^\002\177\000\000\000\000\000\000\000\000\002\177\002\177\nf\nn\002\001\002\001\000\000\000\000\000\000\002\001\000\000\000\000\002\001\000\000\000\000\002\001\000\000\002\001\000\000\000\000\002\001\000\000\002\001\002\001\002\001\000\000\002\001\002\001\002\001\000\000\000\000\000\000\000\000\000\000\002\001\002\001\002\001\002\001\002\001\000\000\002\001\000\000\000\000\000\000\000\000\000\000\002\001\002\001\002\001\002\001\002\001\000\000\000\000\000\000\000\000\002\001\000\000\002\001\002\001\000\000\000\000\000\000\000\000\002\001\002\001\002\001\000\000\000\000\000\000\000\000\000\000\000\000\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\000\000\000\000\002\001\000\000\002\001\002\001\000\000\000\000\000\000\000\000\000\000\000\000\002\001\002\001\002\001\000\000\002\001\002\001\002\001\002\001\000\000\000\000\000\000\002\001\000\000\002\001\002\001\000\000\002\001\002\001\002\001\002\001\002\001\002\001\000\000\000\000\002\001\002\001\r\226\000\000\000\000\000\000\000\000\002\001\002\001\002\001\002\001\002\029\002\029\000\000\000\000\000\000\002\029\000\000\000\000\002\029\000\000\000\000\002\029\000\000\002\029\000\000\000\000\t\174\000\000\002\029\002\029\002\029\000\000\002\029\002\029\002\029\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\029\000\000\000\000\000\000\000\000\000\000\002\029\002\029\n\022\n\030\002\029\000\000\000\000\000\000\000\000\002\029\000\000\n&\002\029\000\000\000\000\000\000\000\000\002\029\002\029\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\029\002\029\t\182\t\246\n.\n6\nF\002\029\002\029\000\000\000\000\002\029\000\000\002\029\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\029\002\029\nV\000\000\002\029\002\029\r\250\002\029\000\000\000\000\000\000\002\029\000\000\002\029\002\029\000\000\nv\002\029\n~\n>\002\029\002\029\000\000\000\000\002\029\n^\002\029\000\000\000\000\000\000\000\000\002\029\002\029\nf\nn\002\025\002\025\000\000\000\000\000\000\002\025\000\000\000\000\002\025\000\000\000\000\002\025\000\000\002\025\000\000\000\000\t\174\000\000\002\025\002\025\002\025\000\000\002\025\002\025\002\025\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\025\000\000\000\000\000\000\000\000\000\000\002\025\002\025\n\022\n\030\002\025\000\000\000\000\000\000\000\000\002\025\000\000\n&\002\025\000\000\000\000\000\000\000\000\002\025\002\025\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\025\002\025\t\182\t\246\n.\n6\nF\002\025\002\025\000\000\000\000\002\025\000\000\002\025\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\025\002\025\nV\000\000\002\025\002\025\002\025\002\025\000\000\000\000\000\000\002\025\000\000\002\025\002\025\000\000\nv\002\025\n~\n>\002\025\002\025\000\000\000\000\002\025\n^\002\025\000\000\000\000\000\000\000\000\002\025\002\025\nf\nn\002\173\002\173\000\000\000\000\000\000\002\173\000\000\000\000\002\173\000\000\000\000\002\173\000\000\002\173\000\000\000\000\t\174\000\000\002\173\002\173\002\173\000\000\002\173\002\173\002\173\000\000\000\000\000\000\000\000\000\000\t\230\t\254\n\006\t\238\n\014\000\000\002\173\000\000\000\000\000\000\000\000\000\000\002\173\002\173\n\022\n\030\002\173\000\000\000\000\000\000\000\000\002\173\000\000\n&\002\173\000\000\000\000\000\000\000\000\002\173\002\173\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\173\002\173\t\182\t\246\n.\n6\nF\002\173\002\173\000\000\000\000\002\173\000\000\002\173\nN\000\000\000\000\000\000\000\000\000\000\000\000\002\173\002\173\nV\000\000\002\173\002\173\002\173\002\173\000\000\000\000\000\000\002\173\000\000\002\173\002\173\000\000\nv\002\173\n~\n>\002\173\002\173\000\000\000\000\002\173\n^\002\173\000\000\000\000\000\000\000\000\002\173\002\173\nf\nn\002\r\002\r\000\000\000\000\000\000\002\r\000\000\000\000\002\r\000\000\000\000\002\r\000\000\002\r\000\000\000\000\002\r\000\000\002\r\002\r\002\r\000\000\002\r\002\r\002\r\000\000\000\000\000\000\000\000\000\000\002\r\002\r\002\r\002\r\002\r\000\000\002\r\000\000\000\000\000\000\000\000\000\000\002\r\002\r\002\r\002\r\002\r\000\000\000\000\000\000\000\000\002\r\000\000\002\r\002\r\000\000\000\000\000\000\000\000\002\r\002\r\002\r\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\r\002\r\002\r\002\r\002\r\002\r\002\r\002\r\000\000\000\000\002\r\000\000\002\r\002\r\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\r\002\r\000\000\002\r\002\r\002\r\002\r\000\000\000\000\000\000\002\r\000\000\002\r\002\r\000\000\002\r\002\r\002\r\002\r\002\r\002\r\000\000\000\000\002\r\002\r\r\226\000\000\000\000\000\000\000\000\002\r\002\r\002\r\002\r\002\017\002\017\000\000\000\000\000\000\002\017\000\000\000\000\002\017\000\000\000\000\002\017\000\000\002\017\000\000\000\000\002\017\000\000\002\017\002\017\002\017\000\000\002\017\002\017\002\017\000\000\000\000\000\000\000\000\000\000\002\017\002\017\002\017\002\017\002\017\000\000\002\017\000\000\000\000\000\000\000\000\000\000\002\017\002\017\002\017\002\017\002\017\003\253\000\000\000\000\000\000\002\017\000\000\002\017\002\017\000\000\000\000\000\000\000\000\002\017\002\017\002\017\000\000\000\000\000\000\000\000\000\000\000\000\002\017\002\017\002\017\002\017\002\017\002\017\002\017\002\017\002\017\000\000\000\000\002\017\000\000\002\017\002\017\000\000\000\000\000\000\000\000\000\000\000\238\002\017\002\017\002\017\000\000\002\017\002\017\002\017\002\017\000\000\000\000\000\000\002\017\000\000\002\017\002\017\000\000\002\017\002\017\002\017\002\017\002\017\002\017\000\000\000\000\002\017\002\017\r\226\000\000\000\000\003\253\000\000\002\017\002\017\002\017\002\017\001\006\000\000\000\006\000\000\007\r\000\000\002\158\002\162\006\014\002\206\002f\005\206\b\214\000\000\000\000\002\218\001\n\012\181\006\026\000\000\002r\000\000\006&\007\r\000\000\001\210\000\000\007\r\000\000\003\026\001\018\bR\bV\001\030\001\"\000\000\000\000\012\181\003*\000\000\002\226\000\000\025\002\002\030\bz\b~\000\000\003\194\003\022\003\206\b\130\006\186\000\000\001:\000\000\002\150\002&\000\000\003\030\002*\012\161\000\000\007\254\b\002\b\014\b\"\000\000\005Z\000\000\000\000\001>\001B\001F\001J\001N\000\000\000\000\b\150\001R\000\000\007\001\000\000\001V\000\000\b\162\b\186\t\014\005f\005j\000\000\000\000\001Z\000\000\000\000\000\000\007\r\000\000\001^\000\000\007\001\000\000\000\000\000\000\007\001\012\181\012\161\000\000\001\154\n\246\000\000\n\178\005n\b\022\n\190\001\158\000\000\014*\004V\t\"\001\006\001\166\000\006\001\170\001\174\012\181\002\158\002\162\000\000\002\206\002f\002\030\000\000\000\000\000\000\002\218\001\n\000\000\002\"\000\000\bN\000\000\000\238\000\000\002&\001\210\000\000\002*\012\161\003\026\001\018\bR\bV\001\030\001\"\000\000\000\000\000\000\003*\000\000\002\226\000\000\bZ\000\000\bz\b~\000\000\003\194\003\022\003\206\b\130\006\186\000\000\001:\000\000\002\150\006\229\000\000\003\030\000\000\000\000\000\000\007\254\b\002\b\014\b\"\006\014\005Z\000\000\005\206\001>\001B\001F\001J\001N\006\229\006\026\b\150\001R\006\229\006&\000\000\001V\000\000\b\162\b\186\t\014\005f\005j\000\000\000\000\001Z\000\000\000\000\000\000\000\000\000\000\001^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\154\005\250\000\000\000\000\005n\b\022\000\000\001\158\000\000\014*\004V\t\"\004m\001\166\000\006\001\170\001\174\000\246\002\158\002\162\002\166\002\206\002f\000\000\002\225\000\000\000\000\002\218\018f\000\000\003\150\000\000\000\000\000\000\004m\000\000\003\154\001\210\000\000\016\254\006\229\002\222\000\000\003\"\003&\000\000\000\000\000\000\003\158\000\000\003*\000\000\002\226\000\n\016\146\000\000\003\186\003\190\003\254\003\194\003\022\003\206\003\214\006\186\000\000\000\000\016\246\002\150\000\000\002\225\003\030\017\014\000\000\000\000\007\254\b\002\b\014\b\"\000\000\005Z\000\000\002\225\002\225\000\000\000\000\000\000\000\000\017\022\000\000\b\150\000\000\t\r\000\000\000\000\000\000\000\000\b\162\b\186\t\014\005f\005j\017*\017V\000\000\000\000\004m\004m\000\000\000\000\000\000\006J\024\206\000\000\t\r\000\000\000\000\015f\000\000\000\000\002f\000\000\017\146\021~\005n\b\022\024\238\000\173\000\000\b.\004V\t\"\000\173\000\000\002\162\000\173\000\000\002f\021&\tJ\000\000\000\000\002\218\000\000\000\000\000\173\000\000\000\173\000\000\000\173\000\000\000\173\001\210\000\238\tR\000\000\002\222\000\000\015j\000\000\000\000\000\000\tZ\000\173\000\000\000\000\000\000\002\226\000\000\000\173\000\000\000\000\015v\000\173\021J\003\022\001\190\015f\000\173\000\000\002f\000\173\002\150\000\000\000\000\003\030\000\173\000\173\000\173\007\254\b\002\b\014\000\000\012J\005Z\000\173\000\173\006\014\005j\000\000\005\206\024\210\000\173\000\000\000\000\t\r\000\173\006\026\021V\000\000\000\000\006&\000\000\000\000\005f\005j\000\173\000\173\015j\000\000\000\173\000\173\000\000\000\000\000\000\020\234\000\000\000\000\000\000\000\000\000\173\000\000\015v\000\000\021*\000\000\000\173\000\173\005n\b\022\000\000\000\000\000\197\b.\004V\000\000\000\173\000\197\000\173\002\162\000\197\000\000\002f\000\000\tJ\000\000\000\000\002\218\005j\000\000\000\197\000\000\000\197\000\000\000\197\000\000\000\197\001\210\0216\tR\000\000\002\222\003\178\000\000\002\162\000\000\000\000\tZ\000\197\000\000\b\182\003\142\002\226\000\000\000\197\020\234\000\000\007\198\000\197\000\000\003\022\001\190\001\210\000\197\000\000\000\000\000\197\002\150\000\000\000\000\003\030\000\197\000\197\000\197\007\254\b\002\b\014\000\000\012J\005Z\000\197\000\197\000\000\000\000\000\000\003\174\000\000\000\197\000\000\000\000\r\206\000\197\002\150\000\000\000\000\000\000\000\000\000\000\000\000\005f\005j\000\197\000\197\000\000\000\000\000\197\000\197\000\000\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\197\000\000\000\000\000\000\000\000\006\206\000\197\000\197\005n\b\022\000\000\000\000\000\000\b.\004V\000\000\000\197\000\000\000\197\000\014\000\018\000\022\000\026\000\030\000\000\000\"\000&\000*\000.\0002\000\000\0006\000:\000\000\000\000\000>\000\000\006\014\000\000\000B\005\206\000\000\012\181\012\161\000\000\000\000\000F\006\026\000\000\000\000\000\000\006&\000J\000\000\000N\000R\000V\000Z\000^\000b\000f\000\000\012\181\000\000\000j\000n\000\000\000r\002\030\000v\000\000\000\000\000\000\000\000\000\000\002\178\000\000\000\000\000\000\000\000\000\000\002&\000\000\000z\002*\012\161\000~\000\130\000\000\000\000\000\000\000\000\000\000\000\134\000\138\000\142\000\000\000\000\000\000\000\000\000\000\000\146\000\150\000\154\000\158\000\000\000\162\000\166\000\170\000\000\000\000\000\000\000\174\000\178\000\182\000\000\000\000\000\000\000\186\000\006\000\190\000\194\000\246\002\158\002\162\002\166\002\206\002f\000\198\000\000\000\202\000\000\002\218\000\000\000\000\004\141\000\206\000\210\000\000\000\214\000\000\003\154\001\210\000\000\000\000\000\000\002\222\000\000\003\"\003&\000\000\000\000\000\000\003\158\000\000\003*\000\000\002\226\000\000\016\146\000\000\003\186\003\190\000\000\003\194\003\022\003\206\003\214\006\186\000\000\000\000\016\246\002\150\000\000\000\000\003\030\017\014\000\000\000\000\007\254\b\002\b\014\b\"\000\000\005Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\022\000\000\b\150\000\000\027\222\000\000\000\000\000\000\000\000\b\162\b\186\t\014\005f\005j\017*\017V\000\000\000\006\027\255\014\190\000\246\002\158\002\162\002\166\002\206\002f\000\000\000\000\000\000\000\000\002\218\000\000\000\000\028.\000\000\021~\005n\b\022\014>\003\154\001\210\b.\004V\t\"\002\222\000\000\003\"\003&\000\000\000\000\000\000\003\158\000\000\003*\000\000\002\226\000\000\016\146\000\000\003\186\003\190\000\000\003\194\003\022\003\206\003\214\006\186\000\000\016R\016\246\002\150\000\000\000\000\003\030\017\014\002\006\000\000\007\254\b\002\b\014\b\"\000\000\005Z\000\000\000\000\002\n\000\000\000\000\000\000\000\000\017\022\000\000\b\150\001\210\027\222\000\000\000\000\000\000\000\000\b\162\b\186\t\014\005f\005j\017*\017V\000\000\000\000\004\149\000\000\003~\000\000\000\000\000\000\001\006\000\000\006\230\001\222\000\000\000\000\003:\002\162\b\246\002\150\002f\021~\005n\b\022\000\000\002\218\001\n\b.\004V\t\"\002r\000\000\000\000\000\000\000\000\001\210\000\000\000\000\000\000\001\014\001\018\001\022\003Z\001\030\001\"\000\000\000\000\006\234\000\000\000\000\002\225\000\000\003^\002\225\001.\n\242\000\000\000\000\003V\001\190\0016\002\225\000\000\001:\000\000\002\150\000\000\000\000\003\218\000\000\000\000\002\225\003\222\000\000\003\230\005N\000\n\005Z\000\000\002\225\001>\001B\001F\001J\001N\000\000\000\000\000\n\001R\005^\000\000\002\225\001V\000\000\000\000\000\000\002\225\005f\005j\000\000\005\174\001Z\002\225\002\225\002\225\002\225\000\000\001^\000\000\002\225\000\000\000\000\000\000\000\000\000\000\002\225\000\000\001\154\n\246\011\002\000\000\005n\000\000\000\000\001\158\000\000\001\162\004V\001\006\000\000\001\166\002\225\001\170\001\174\003:\002\162\n\150\002\225\002f\011\006\000\000\000\000\000\000\002\218\001\n\000\000\000\000\000\000\002r\000\000\000\000\000\000\000\000\001\210\000\000\000\000\000\000\001\014\001\018\001\022\003Z\001\030\001\"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003^\000\000\001.\n\242\000\000\000\000\003V\001\190\0016\000\000\000\238\001:\000\000\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\001>\001B\001F\001J\001N\000\000\000\000\000\000\001R\005^\000\000\000\000\001V\007\173\000\000\000\000\000\000\005f\005j\000\000\005\174\001Z\000\000\000\000\000\000\000\000\006\014\001^\000\000\005\206\011\n\000\000\000\000\000\000\000\000\000\000\006\026\001\154\n\246\000\000\006&\005n\000\000\007\173\001\158\000\000\001\162\004V\001\006\000\000\001\166\000\000\001\170\001\174\003:\002\162\r\142\007\173\002f\000\000\007\173\b\138\000\000\002\218\001\n\000\000\000\000\007\173\002r\000\000\000\000\007\173\000\000\001\210\000\000\000\000\000\000\001\014\001\018\001\022\003Z\001\030\001\"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003^\000\000\001.\n\242\000\000\000\000\003V\001\190\0016\n\181\000\000\001:\000\000\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\001>\001B\001F\001J\001N\000\000\000\000\000\000\001R\005^\000\000\n\181\001V\000\000\000\000\000\000\000\000\005f\005j\000\000\005\174\001Z\000\000\000\000\000\000\n\181\000\000\001^\n\181\011j\000\000\000\000\000\000\000\000\000\000\n\181\000\000\001\154\n\246\n\181\000\000\005n\000\000\000\000\001\158\000\000\001\162\004V\000\000\b\249\001\166\000\006\001\170\001\174\000\000\002\158\002\162\000\000\002\206\002f\000\000\000\000\000\000\000\000\002\218\000\000\000\000\000\000\000\000\b\249\000\000\b\249\b\249\000\000\001\210\000\000\000\000\000\000\002\222\000\000\003\"\003&\000\000\000\000\000\000\000\000\b\001\003*\000\000\002\226\000\000\b\001\000\000\003\186\003\190\n\194\003\194\003\022\003\206\003\214\006\186\001\202\001\206\011\"\002\150\000\000\000\000\003\030\000\000\000\000\b\001\007\254\b\002\b\014\b\"\000\000\005Z\000\000\000\000\000\000\001\210\002\142\001\230\000\000\000\000\000\000\b\150\000\000\000\000\000\000\001\242\000\000\b\001\b\162\b\186\t\014\005f\005j\000\000\000\000\b\001\000\000\000\000\001\246\002v\b\001\b\001\000\238\002\130\000\000\002\150\004\002\004\014\000\000\b\001\b\001\000\000\004\026\000\000\000\000\005n\b\022\b\249\004\253\004\253\b.\004V\t\"\004\253\000\000\004\253\004\253\000\000\004\253\004\030\004\253\004\253\b\001\000\000\004\253\b\001\004\253\004\253\004\253\004\253\004\253\004\253\004\253\004\253\b\001\004\253\016b\004\253\000\000\000\000\000\000\000\000\000\000\002\006\004\253\000\000\000\000\000\000\000\000\004\253\004\253\004\253\000\000\002\n\004\253\004\253\004\253\004\253\000\000\004\253\000\000\001\210\004\253\000\000\000\000\000\000\000\000\004\253\004\253\004\253\000\000\000\000\004\253\004\253\004\253\000\000\004\253\004\253\003~\000\000\000\000\000\000\000\000\004\253\006\230\001\222\000\000\004\253\004\253\000\000\004\253\002\150\004\253\000\000\000\000\000\000\000\000\004\253\004\253\004\253\000\000\004\253\004\253\004\253\004\253\000\000\004\253\004\253\000\000\000\000\000\000\004\253\000\000\004\253\004\253\000\000\000\000\002z\004\253\006\234\000\000\000\000\019\254\004\253\000\000\n\205\000\000\004\253\n\205\004\253\004\253\n\205\n\205\000\000\004\253\n\205\000\000\n\205\000\000\000\000\n\205\000\000\000\000\000\000\n\205\n\205\000\000\n\205\n\205\000\000\n\205\000\000\n\205\000\000\025\026\002\225\002\225\n\205\000\000\000\000\n\205\002\006\000\000\000\000\000\000\000\000\000\000\000\000\n\205\000\000\n\205\002\n\000\000\n\205\n\205\002\225\000\000\000\000\000\000\001\210\n\205\002\225\000\n\n\205\000\000\000\000\n\205\n\205\002\225\n\205\000\000\n\205\n\205\000\000\002\225\000\000\003~\002\225\002\225\000\000\000\000\000\000\006\230\001\222\n\205\000\000\000\000\000\000\000\000\002\150\002\225\000\000\n\205\n\205\000\000\000\000\n\205\000\000\n\205\000\000\000\000\000\000\000\000\005\138\000\000\000\000\000\000\000\000\001\202\001\206\n\205\n\205\000\000\n\205\n\205\000\000\n\205\006\234\n\205\000\000\n\205\000\000\n\205\000\000\n\205\b\229\b\229\001\210\001\214\001\230\b\229\000\000\001\206\b\229\000\000\000\000\000\000\001\242\000\000\000\000\018\146\b\229\000\000\b\229\b\229\b\229\000\000\b\229\b\229\b\229\001\246\019\250\000\000\019\026\000\000\002\130\000\000\002\150\004\002\004\014\000\000\b\229\000\000\000\000\020\n\000\000\000\000\b\229\b\229\000\000\000\000\b\229\000\000\000\000\002~\000\000\b\229\000\000\000\000\b\229\000\000\004\030\000\000\000\000\b\229\b\229\b\229\000\000\000\000\000\000\000\000\000\000\000\000\b\229\b\229\000\000\000\000\000\000\000\000\000\000\b\229\000\000\000\000\000\000\004~\000\000\000\000\b\229\000\000\000\000\000\000\000\000\000\000\000\000\b\229\b\229\b\229\000\000\b\229\b\229\000\000\004Y\000\000\000\000\000\000\000\000\004Y\000\000\b\229\004Y\b\229\b\229\000\000\000\000\000\000\b\229\000\000\000\000\000\000\004Y\b\229\000\000\000\000\004Y\b\229\004Y\b\229\b\229\012u\012u\000\000\000\000\004Y\012u\000\000\001\206\012u\004Y\000\000\000\000\000\000\000\000\000\000\004Y\004\158\000\000\012u\012u\012u\004&\012u\012u\012u\000\000\000\000\004Y\004Y\000\000\000\000\000\000\004Y\002\198\000\000\000\000\012u\000\000\000\000\000\000\000\000\000\000\012u\012u\000\000\000\000\012u\000\000\004Y\002~\004Y\012u\000\000\000\000\012u\000\000\000\000\000\000\004Y\012u\012u\012u\004Y\004Y\002\198\000\238\004Y\004Y\012u\012u\000\000\000\000\0046\004Y\000\000\012u\000\000\000\000\000\000\004~\000\000\000\000\012u\004Y\000\000\000\000\000\000\000\000\020\254\012u\012u\012u\000\000\012u\012u\000\000\004Y\000\000\004Y\000\000\000\000\004Y\000\000\012u\004Y\012u\012u\004Y\000\000\000\000\012u\000\000\000\000\000\000\004Y\012u\000\000\000\000\004Y\012u\004Y\012u\012u\b\233\b\233\000\000\000\000\000\000\b\233\000\000\001\206\b\233\004Y\000\000\000\000\000\000\000\000\000\000\004Y\b\233\000\000\b\233\b\233\b\233\000\000\b\233\b\233\b\233\000\000\000\000\004Y\000\000\000\000\000\000\000\000\004Y\002\198\000\000\000\000\b\233\000\000\000\000\000\000\000\000\000\000\b\233\b\233\000\000\000\000\b\233\000\000\004Y\002~\000\000\b\233\000\000\000\000\b\233\000\000\000\000\000\000\000\000\b\233\b\233\b\233\004Y\004Y\000\000\000\000\004Y\004Y\b\233\b\233\002\225\000\000\007R\000\000\000\000\b\233\000\000\002\225\000\000\004~\000\000\000\000\b\233\004Y\000\000\000\000\000\000\000\000\002\225\b\233\b\233\b\233\002\225\b\233\b\233\001*\000\n\002\225\002\225\002\225\000\000\000\000\002\225\b\233\002\225\b\233\b\233\002\225\002\225\002\225\b\233\002\225\002\225\002\225\002\225\b\233\002\225\002\225\002\225\b\233\002\225\b\233\b\233\000\000\002\225\000\n\000\000\002\225\000\n\002\225\000\000\002\225\000\000\002\225\002\225\000\n\000\000\002\225\002\225\000\n\002\225\002\225\002\225\002\225\000\000\000\000\002\225\002\225\000\000\002\225\002\225\002\225\002\225\002\225\002\225\000\000\002\225\002\225\000\000\002\225\002\225\002\225\000\000\002\225\002\225\002\225\002\225\002\225\002\225\002\225\000\000\002\225\000\000\000\000\000\000\000\000\000\000\000\000\002\225\002\225\002\225\002\225\002\225\000\000\000\000\000\000\002\225\002\225\002\225\002\225\002\225\000\000\006\141\000\000\0009\002\225\002\225\000\000\0009\0009\000\000\0009\0009\002\225\000\000\000\000\000\000\0009\000\000\002\225\000\000\003\162\006\141\002\225\002\225\000\000\000\000\0009\002\225\002\225\002\225\0009\006\194\0009\0009\000\000\000\000\000\000\000\000\000\000\0009\000\000\0009\000\000\000\000\000\000\0009\0009\000\000\0009\0009\0009\0009\0009\000\000\000\000\000\000\0009\000\000\000\000\0009\000\000\000\000\000\000\0009\0009\0009\0009\000\000\0009\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0009\000\000\000\000\000\000\000\000\000\000\000\000\0009\0009\0009\0009\0009\000\000\006\137\000\000\0005\000\000\000\000\000\000\0005\0005\000\000\0005\0005\000\000\000\000\000\000\000\000\0005\000\000\000\000\000\000\000\000\006\137\0009\0009\000\000\000\000\0005\0009\0009\0009\0005\000\000\0005\0005\000\000\000\000\000\000\000\000\000\000\0005\000\000\0005\000\000\000\000\000\000\0005\0005\000\000\0005\0005\0005\0005\0005\000\000\000\000\000\000\0005\000\000\000\000\0005\000\000\000\000\000\000\0005\0005\0005\0005\000\000\0005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0005\000\000\000\000\000\000\000\000\000\000\000\000\0005\0005\0005\0005\0005\000\000\006\153\000\000\012=\000\000\000\000\000\000\012=\012=\000\000\012=\012=\000\000\000\000\000\000\000\000\012=\000\000\000\000\000\000\000\000\006\153\0005\0005\000\000\000\000\012=\0005\0005\0005\012=\000\000\012=\012=\000\000\000\000\000\000\000\000\000\000\012=\000\000\012=\000\000\000\000\000\000\012=\012=\000\000\012=\012=\012=\012=\012=\000\000\000\000\000\000\012=\000\000\000\000\012=\000\000\000\000\000\000\012=\012=\012=\012=\000\000\012=\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012=\000\000\000\000\000\000\000\000\000\000\000\000\012=\012=\012=\012=\012=\000\000\006\149\000\000\0129\000\000\000\000\000\000\0129\0129\000\000\0129\0129\000\000\000\000\000\000\000\000\0129\000\000\000\000\000\000\000\000\006\149\012=\012=\000\000\000\000\0129\012=\012=\012=\0129\000\000\0129\0129\000\000\000\000\000\000\000\000\000\000\0129\000\000\0129\000\000\000\000\000\000\0129\0129\000\000\0129\0129\0129\0129\0129\000\000\001\202\001\206\0129\000\000\000\000\0129\000\000\000\000\000\000\0129\0129\0129\0129\000\000\0129\000\000\000\000\000\000\000\000\001\210\001\214\001\230\000\000\000\000\0129\000\000\000\000\000\000\000\000\001\242\000\000\0129\0129\0129\0129\0129\001\250\000\000\000\000\000\000\000\000\000\000\001\246\002v\000\000\000\000\000\000\002\130\000\000\002\150\004\002\004\014\012y\012y\000\000\000\000\004\026\012y\0129\0129\012y\000\000\000\000\0129\0129\0129\000\000\000\000\004n\000\000\012y\012y\012y\004\030\012y\012y\012y\000\000\001\021\000\000\000\000\000\000\000\000\001\021\000\000\000\000\000\000\000\000\012y\000\000\000\000\000\000\000\000\000\000\012y\012y\000\000\000\000\012y\000\000\000\000\000\000\001\021\012y\000\000\000\000\012y\000\000\000\000\000\000\000\000\012y\012y\012y\000\000\000\000\000\000\000\000\000\000\000\000\012y\012y\000\000\000\000\001\021\000\000\018\154\012y\000\000\000\000\000\000\012y\001\021\000\000\012y\000\000\000\000\001\021\000\000\000\000\000\000\012y\012y\012y\000\000\012y\012y\001\021\000\000\000\000\000\000\000\000\000\000\000\000\007\253\012y\000\006\012y\012y\007\253\002\158\002\162\012y\002\206\002f\000\000\000\000\012y\000\000\002\218\000\000\012y\001\021\012y\012y\000\000\003\226\000\000\007\253\001\210\000\000\001\021\000\000\002\222\000\000\003\"\003&\000\000\000\000\000\000\000\000\000\000\003*\000\000\002\226\000\000\000\000\000\000\003\186\003\190\007\253\003\194\003\022\003\206\003\214\006\186\000\000\000\000\007\253\002\150\000\000\000\000\003\030\007\253\007\253\000\238\007\254\b\002\b\014\b\"\000\000\005Z\007\253\007\253\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\150\000\000\000\000\000\000\000\000\000\000\000\000\b\162\b\186\t\014\005f\005j\000\000\000\000\007\253\000\000\000\000\007\253\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000\000\007\253\002\158\002\162\000\000\002\206\002f\000\000\000\000\005n\b\022\002\218\000\000\000\000\b.\004V\t\"\000\000\014R\000\000\000\000\001\210\000\000\000\000\000\000\002\222\000\000\003\"\003&\000\000\000\000\000\000\001\197\000\000\003*\000\000\002\226\001\197\000\000\000\000\003\186\003\190\000\000\003\194\003\022\003\206\003\214\006\186\000\000\000\000\000\000\002\150\000\000\000\000\003\030\000\000\001\197\000\000\007\254\b\002\b\014\b\"\000\000\005Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005-\012\217\b\150\000\000\000\000\0051\012\217\001\197\000\000\b\162\b\186\t\014\005f\005j\000\000\001\197\000\000\000\000\000\000\005-\001\197\001\197\000\238\005-\0051\000\000\003\029\003\029\0051\001\197\001\197\003\029\000\000\000\000\003\029\000\000\005n\b\022\000\000\000\000\000\000\b.\004V\t\"\003\029\003\029\003\029\000\000\003\029\003\029\003\029\000\000\000\000\000\000\000\000\001\197\000\000\000\000\000\000\000\000\000\000\000\000\003\029\000\000\001\197\000\000\000\000\000\000\003\029\004f\000\000\000\000\003\029\000\000\000\000\000\000\000\000\003\029\012\217\012\217\003\029\000\000\000\000\012\217\012\217\003\029\003\029\003\029\000\000\000\000\000\000\005-\000\000\000\000\003\029\003\029\0051\012\217\000\000\012\217\000\000\003\029\012\217\000\000\012\217\003\029\005-\000\000\003\029\005-\000\000\0051\000\000\000\000\0051\003\029\003\029\003\029\004}\003\029\003\029\000\000\000\000\018\170\000\000\000\000\000\000\000\000\000\000\003\029\000\000\003\029\003\029\000\000\000\000\000\000\003\029\000\000\000\000\000\000\000\000\003\029\003\154\n\217\000\000\003\029\n\217\003\029\003\029\003:\002\162\000\000\000\000\002f\000\000\006\138\000\000\000\000\002\218\000\000\000\000\000\000\n\217\n\217\018\214\n\217\n\217\000\000\001\210\000\000\006\170\000\000\016\246\000\000\000\000\003>\000\000\017\014\b\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\217\019\018\003J\000\000\000\000\003V\001\190\000\000\000\000\000\000\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\n\217\003\222\000\000\003\230\005N\n\162\005Z\000\000\004}\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\019v\005^\001\202\001\206\000\000\000\000\000\000\000\000\000\000\005f\005j\000\000\005\174\n\217\000\000\n\217\000\000\000\000\000\000\000\000\000\000\001\210\001\214\000\000\000\000\000\000\000\000\n\217\000\000\000\000\n\217\n\217\000\000\005n\000\000\n\217\000\000\n\217\000\000\004V\n\213\n\217\000\000\n\213\001\246\002\134\003:\002\162\000\000\002\130\002f\002\150\004\002\004\014\000\000\002\218\000\000\000\000\004\026\n\213\n\213\000\000\n\213\n\213\000\000\001\210\000\000\000\000\000\000\000\000\000\000\000\000\003>\000\000\000\000\004\030\000\000\000\000\025\250\000\000\000\000\000\000\000\000\n\213\000\000\003J\000\000\000\000\003V\001\190\000\000\000\000\000\000\000\000\025\230\002\150\000\000\000\000\003\218\000\000\000\000\n\213\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\000\000\012Y\000\000\000\000\012Y\000\000\000\000\005f\005j\000\000\005\174\n\213\000\000\n\213\012Y\000\000\000\000\000\000\000\000\000\000\012Y\000\000\001\221\001\221\000\000\n\213\000\000\001\221\n\213\n\213\001\221\005n\012Y\n\213\000\000\n\213\000\000\004V\012Y\n\213\001\221\001\221\001\221\000\000\001\221\001\221\001\221\012Y\000\000\000\000\012Y\000\000\000\000\000\000\000\000\012Y\000\000\000\000\001\221\000\000\000\000\000\000\000\000\000\000\001\221\001\221\000\000\000\000\001\221\000\000\000\000\012Y\000\000\001\221\000\000\012Y\001\221\000\000\000\000\000\000\000\000\001\221\001\221\001\221\000\000\012Y\012Y\000\000\000\000\012Y\001\221\001\221\000\000\000\000\000\000\027\214\000\000\001\221\001\r\000\000\000\000\001\221\000\000\001\r\001\221\000\000\012Y\000\000\000\000\000\000\000\000\001\221\001\221\001\221\000\000\001\221\001\221\000\000\000\000\000\000\000\000\000\000\001\r\000\000\000\000\001\221\000\000\001\221\001\221\003:\002\162\000\000\001\221\002f\000\000\006\138\000\000\001\221\002\218\000\000\000\000\004\226\000\000\001\221\001\r\000\000\0036\000\000\001\210\000\000\006\170\000\000\001\r\000\000\000\000\003>\000\000\001\r\b\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\r\001\r\003J\000\000\000\000\n\146\001\190\000\000\000\000\000\000\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\n\177\003\222\000\000\003\230\000\000\n\162\005Z\000\000\001\r\000\000\003:\002\162\000\000\000\000\002f\000\000\006\138\001\r\005^\002\218\000\000\000\000\000\000\000\000\000\000\000\000\005f\005j\000\000\001\210\n\170\006\170\000\000\000\000\000\000\000\000\003>\000\000\000\000\b\198\000\000\000\000\000\000\000\000\n\177\n\178\000\000\n\177\011\030\003J\005n\000\000\n\146\001\190\n\177\000\000\004V\000\000\n\177\002\150\000\000\000\000\003\218\000\000\000\000\n\177\003\222\000\000\003\230\000\000\n\162\005Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005f\005j\000\000\000\000\n\170\005}\005}\000\000\000\000\000\000\005}\000\000\000\000\005}\000\000\000\000\000\000\000\000\n\177\000\000\000\000\n\177\n\177\005}\005n\005}\000\000\005}\n\177\005}\004V\000\000\n\177\000\000\000\000\000\000\000\000\000\000\000\000\000\246\000\000\005}\002\166\000\000\000\000\000\000\000\000\005}\005}\000\000\000\000\000\000\028.\005}\000\000\000\000\005}\000\000\003\154\005}\000\000\000\000\000\000\000\000\005}\005}\005}\000\000\000\000\000\000\003\158\000\000\000\000\000\000\000\000\000\000\016\146\000\000\000\000\000\000\005}\005}\000\000\000\000\005}\024>\000\000\001\006\016\246\000\000\000\000\000\000\000\000\017\014\005}\005}\005}\000\000\005}\005}\000\000\000\000\000\000\001\n\007R\000\000\000\000\002r\000\000\017\022\000\000\005}\000\000\027\222\005}\005}\001\014\001\018\001\022\001\026\001\030\001\"\000\000\017*\017V\000\000\005}\004\149\000\000\001&\000\000\001.\0012\000\000\000\000\000\000\000\000\0016\004a\000\000\001:\000\000\000\000\000\246\021~\000\000\002\018\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\150\001>\001B\001F\001J\001N\003\154\005q\005q\001R\000\000\000\000\005q\001V\000\000\005q\000\000\000\000\017\154\000\000\000\000\000\000\001Z\000\000\017\194\005q\000\000\005q\001^\005q\000\000\005q\000\000\000\000\000\000\000\000\016\246\000\000\001\154\027\018\000\000\017\014\000\000\005q\000\000\001\158\000\000\001\162\000\000\005q\005q\001\166\000\000\001\170\001\174\007\194\000\000\018>\005q\000\000\000\000\005q\000\000\000\000\000\000\000\000\005q\005q\000\238\000\000\000\000\017*\018R\000\000\000\000\004a\004a\000\000\000\000\000\000\000\000\000\000\005q\005q\000\000\000\000\005q\000\000\b\245\000\000\000\000\000\000\018b\000\000\000\000\000\000\005q\005q\005q\000\000\005q\005q\000\000\000\000\t\174\000\000\000\000\012\030\b\245\000\000\b\245\b\245\000\000\005q\000\000\000\000\005q\005q\t\230\t\254\n\006\t\238\n\014\000\000\000\000\001\202\002b\000\000\005q\002f\000\000\000\000\n\022\n\030\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n&\000\000\000\000\001\210\001\214\001\230\002j\000\000\000\238\000\000\000\000\000\000\000\000\001\242\001\006\000\000\000\000\t\182\t\246\n.\n6\nF\000\000\000\000\000\000\000\000\002n\002v\000\000\nN\001\n\002\130\000\000\002\150\004\002\004\014\000\000\000\000\nV\000\000\020\214\000\000\020\218\001\014\001\018\001\022\001\026\001\030\001\"\000\000\000\000\000\000\nv\000\000\n~\n>\001&\004\030\001.\0012\b\245\n^\000\000\000\000\0016\000\000\005j\001:\000\000\nf\nn\000\000\000\000\000\000\000\000\000\000\020\230\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001>\001B\001F\001J\001N\000\000\003]\003]\001R\020\234\000\000\003]\001V\000\000\003]\000\000\000\000\000\000\000\000\000\000\000\000\001Z\000\000\000\000\003]\000\000\003]\001^\003]\000\000\003]\000\000\000\000\000\000\000\000\000\000\000\000\001\154\027.\000\000\000\000\000\000\003]\000\000\001\158\000\000\001\162\000\000\003]\003]\001\166\000\000\001\170\001\174\005\005\000\000\000\000\003]\000\000\000\000\003]\000\000\000\000\000\000\000\000\003]\003]\003]\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003]\000\000\001\202\001\206\003]\bq\bq\000\000\000\000\000\000\bq\000\000\000\000\bq\003]\003]\003]\000\000\003]\003]\000\000\001\210\001\214\bq\005\005\bq\000\000\bq\000\000\bq\000\000\003]\000\000\000\000\000\000\003]\000\000\000\000\000\000\000\000\000\000\bq\000\000\000\000\001\246\002~\003]\bq\bq\002\130\000\000\002\150\004\002\004\014\000\000\000\000\bq\000\000\004\026\bq\015\130\000\000\000\000\000\000\bq\bq\bq\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\030\000\000\000\000\000\000\000\000\bq\000\000\000\000\000\000\bq\r%\r%\000\000\000\000\000\000\r%\000\000\000\000\r%\bq\bq\bq\000\000\bq\bq\000\000\000\000\000\000\r%\000\000\r%\000\000\r%\bq\r%\000\000\bq\000\000\000\000\000\000\bq\000\000\000\000\000\000\000\000\000\000\r%\000\000\000\000\004\226\000\000\bq\r%\r%\r)\r)\000\000\000\000\004&\r)\000\000\r%\r)\000\000\r%\000\000\000\000\000\000\000\000\r%\r%\r%\r)\000\000\r)\000\000\r)\000\000\r)\000\000\000\000\000\000\000\000\000\000\000\000\r%\000\000\000\000\000\000\r%\r)\000\000\000\000\000\000\000\000\000\000\r)\r)\000\000\r%\r%\r%\004&\r%\r%\r)\000\000\000\000\r)\0046\000\000\000\000\000\000\r)\r)\r)\r%\000\000\000\000\000\000\r%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r)\000\000\r%\000\000\r)\003]\003]\000\000\000\000\000\000\003]\000\000\000\000\003]\r)\r)\r)\000\000\r)\r)\000\000\000\000\000\000\003]\0046\003]\000\000\003]\000\000\003]\000\000\r)\001\202\001\206\000\000\r)\000\000\000\000\000\000\000\000\000\000\003]\000\000\000\000\000\000\000\000\r)\003]\003]\000\000\000\000\001\210\001\214\005\t\000\000\000\000\003]\000\000\000\000\003]\000\000\000\000\000\000\000\000\003]\003]\003]\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\246\002\134\000\000\000\000\000\000\002\130\003]\002\150\004\002\004\014\003]\001\205\000\000\000\000\004\026\000\000\001\205\000\000\001\206\001\205\003]\003]\003]\000\000\003]\003]\000\000\b\209\000\000\001\205\005\t\004\030\000\000\001\205\004\205\001\205\000\000\003]\000\000\000\000\000\000\003]\000\000\004Y\000\000\000\000\000\000\001\205\004Y\000\000\025\230\000\000\003]\001\205\001\205\000\000\000\000\000\000\000\000\000\000\002~\000\000\001\205\000\000\000\000\001\205\000\000\004Y\000\000\000\000\001\205\001\205\001\205\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\205\001\205\000\000\004Y\004~\003A\000\000\000\000\000\000\000\000\003A\004Y\001\206\003A\001\205\001\205\004Y\002\198\001\205\001\205\000\000\b\205\000\000\003A\000\000\004Y\004Y\003A\001\205\003A\000\000\000\000\000\000\000\000\000\000\001\205\000\000\000\000\000\000\000\000\001\205\003A\000\000\000\000\000\000\000\000\001\205\003A\001\201\000\000\000\181\004Y\000\000\000\000\002~\000\181\003A\000\000\000\181\003A\004Y\000\000\000\000\000\000\003A\003A\003A\000\000\000\181\000\000\000\181\000\000\000\181\000\000\000\181\000\000\000\000\000\000\000\000\000\000\003A\003A\000\000\000\000\004~\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\181\000\000\003A\003A\000\181\000\000\003A\003A\000\000\000\181\000\000\000\000\000\181\000\000\000\000\000\000\003A\000\181\000\181\000\238\000\000\000\000\000\000\003A\000\000\000\000\000\181\000\181\003A\000\000\000\000\000\000\000\000\000\181\003A\000\000\000\249\000\181\000\000\000\000\000\000\000\249\000\000\000\000\000\249\000\000\000\000\000\181\000\181\000\000\000\000\000\181\000\181\000\000\000\249\000\000\000\249\000\000\000\249\000\000\000\249\000\181\000\000\000\000\000\000\000\000\000\000\000\181\000\181\000\000\000\000\000\000\000\249\000\000\000\000\000\000\000\000\000\181\000\249\000\181\000\000\000\000\000\249\000\000\000\000\000\000\000\000\000\249\000\000\000\000\000\249\000\000\000\000\000\000\000\000\000\249\000\249\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\249\000\249\000\000\000\000\000\000\000\000\000\000\000\249\000\000\000\000\000\189\000\249\000\000\000\000\000\000\000\189\000\000\000\000\000\189\000\000\000\000\000\249\000\249\000\000\000\000\000\249\000\249\000\000\000\189\000\000\000\189\000\000\000\189\000\000\000\189\000\249\000\000\000\000\000\000\000\000\000\000\000\249\000\249\000\000\000\000\000\000\000\189\000\000\000\000\000\000\000\000\000\249\000\189\000\249\000\000\000\000\000\189\000\000\000\000\000\000\000\000\000\189\000\000\000\000\000\189\000\000\000\000\000\000\000\000\000\189\000\189\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\189\000\189\000\000\000\000\000\000\000\000\000\000\000\189\000\000\000\000\000\185\000\189\000\000\000\000\006\221\000\185\000\000\000\000\000\185\006\221\000\000\000\189\000\189\000\000\000\000\000\189\000\189\000\000\000\185\000\000\000\185\000\000\000\185\000\000\000\185\000\189\000\000\000\000\006\221\000\000\000\000\000\189\000\189\000\000\000\000\000\000\000\185\000\000\000\000\000\000\000\000\000\189\000\185\000\189\000\000\000\000\000\185\000\000\000\000\000\000\006\221\000\185\000\000\000\000\000\185\000\000\000\000\000\000\006\221\000\185\000\185\000\238\000\000\006\221\006\221\000\238\000\000\000\000\000\185\000\185\000\000\000\000\006\221\006\221\000\000\000\185\000\000\000\000\001\169\000\185\000\000\000\000\000\000\001\169\000\000\000\000\001\169\000\000\000\000\000\185\000\185\000\000\000\000\000\185\000\185\000\000\001\169\000\000\006\221\000\000\001\169\012\229\001\169\000\185\000\000\000\000\012\229\006\221\000\000\000\185\000\185\000\000\000\000\000\000\001\169\001\169\000\000\000\000\000\000\000\185\001\169\000\185\000\000\023\158\000\000\012\229\005\005\000\000\000\000\001\169\000\000\000\000\001\169\000\000\000\000\000\000\000\000\001\169\001\169\001\169\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\229\000\000\000\000\000\000\000\000\000\000\001\169\000\000\012\229\000\000\001\169\r!\r!\012\229\012\229\000\238\r!\000\000\000\000\r!\001\169\001\169\012\229\012\229\001\169\001\169\000\000\000\000\000\000\r!\005\005\r!\000\000\r!\001\169\r!\000\000\000\000\000\000\000\000\001\169\001\169\000\000\000\000\000\000\000\000\001\169\r!\012\229\000\000\000\000\000\000\001\169\r!\r!\000\000\000\000\012\229\000\000\000\000\000\000\000\000\r!\000\000\000\000\r!\000\000\000\000\000\000\000\000\r!\r!\r!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r!\000\000\000\000\000\000\r!\r\029\r\029\000\000\000\000\000\000\r\029\000\000\000\000\r\029\r!\r!\r!\000\000\r!\r!\000\000\000\000\000\000\r\029\000\000\r\029\000\000\r\029\000\000\r\029\000\000\r!\000\000\000\000\000\000\r!\000\000\000\000\000\000\000\000\000\000\r\029\000\000\000\000\004\226\000\000\r!\r\029\r\029\000\000\000\000\000\000\000\000\000\000\000\000\004a\r\029\000\000\000\000\r\029\000\246\000\000\000\000\002\018\r\029\r\029\r\029\000\000\000\000\000\000\000\000\000\000\000\000\017\150\000\000\000\000\000\000\004a\000\000\003\154\r\029\000\000\bu\bu\r\029\000\000\000\000\bu\000\000\000\000\bu\017\154\000\000\000\000\r\029\r\029\r\029\017\194\r\029\r\029\bu\000\000\bu\000\000\bu\000\000\bu\000\000\007.\016\246\000\000\r\029\000\000\000\000\017\014\r\029\000\000\000\000\bu\000\000\000\000\000\000\000\000\000\000\bu\bu\r\029\000\000\000\000\000\000\018>\000\000\000\000\bu\000\000\000\000\bu\000\000\000\000\000\000\000\000\bu\bu\000\238\017*\018R\000\000\000\000\004a\004a\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bu\000\000\000\000\000\000\bu\000\000\006\241\000\000\018b\000\000\000\000\000\000\000\000\000\000\bu\bu\bu\000\000\bu\bu\000\000\000\000\t\174\000\000\000\000\006\241\000\000\000\000\bu\006\241\000\000\bu\000\000\000\000\000\000\bu\t\230\t\254\n\006\t\238\n\014\000\000\000\000\000\000\000\000\000\000\bu\001\201\000\000\000\000\n\022\n\030\001\201\000\000\001\206\001\201\000\000\000\000\000\000\n&\000\000\000\000\000\000\b\205\000\000\001\201\000\000\000\238\000\000\001\201\000\000\001\201\000\000\000\000\000\000\000\000\t\182\t\246\n.\n6\nF\000\000\000\000\001\201\000\000\000\000\000\000\006\241\nN\001\201\000\000\000\000\000\000\000\000\000\000\000\000\002~\nV\001\201\000\000\000\000\001\201\000\000\000\000\000\000\000\000\001\201\001\201\001\201\000\000\000\000\nv\000\000\n~\n>\000\000\000\000\000\000\000\000\000\000\n^\000\000\001\201\001\201\000\000\000\000\004~\000\000\nf\nn\000\000\000\000\000\000\016F\000\000\000\000\001\201\001\201\000\000\000\000\001\201\001\201\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\174\001\201\000\000\000\000\016J\000\000\000\000\000\000\001\201\000\000\000\000\000\000\000\000\001\201\t\230\t\254\n\006\t\238\n\014\001\201\000\000\000\000\000\000\000\000\000\000\n\182\000\000\000\000\n\022\n\030\000\246\001\202\001\206\002\018\000\000\000\000\000\000\n&\000\000\000\000\000\000\000\000\000\000\017\150\000\000\000\238\000\000\004a\000\000\003\154\001\210\001\214\001\230\000\000\t\182\t\246\n.\n6\nF\000\000\001\242\017\154\000\000\000\000\000\000\000\000\nN\017\194\000\000\000\000\000\000\000\000\000\000\001\246\002v\nV\000\000\000\000\002\130\016\246\002\150\004\002\004\014\000\000\017\014\000\000\000\000\004\026\000\000\nv\016N\n~\n>\016^\000\000\000\000\000\000\000\000\n^\000\000\018>\000\000\000\000\000\000\004\030\000\000\nf\nn\005\169\005\169\000\000\000\000\000\000\005\169\017*\018R\005\169\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\169\000\000\005\169\000\000\005\169\000\000\005\169\000\000\000\000\018b\000\000\000\000\000\000\000\000\004R\000\000\004V\000\000\005\169\000\000\000\000\000\000\000\000\000\000\005\169\005\169\000\000\000\000\000\000\000\000\007\194\000\000\000\000\005\169\000\000\000\000\005\169\000\000\006I\000\000\000\000\005\169\005\169\000\238\000\000\002\162\000\000\000\000\002f\000\000\000\000\000\000\000\000\002\218\000\000\002\225\002\225\005\169\006I\002\225\000\000\005\169\000\000\001\210\002\225\000\000\000\000\002\222\000\000\000\000\002\225\005\169\005\169\005\169\002\225\005\169\005\169\000\000\002\226\000\000\000\000\002\225\000\n\000\000\000\000\006\190\003\022\001\190\005\169\000\000\000\000\015\030\005\169\002\150\002\225\000\000\003\030\002\225\002\225\000\000\007\254\b\002\b\014\005\169\002\225\005Z\000\000\002\225\000\000\000\000\002\225\002\225\000\000\002\225\002\225\000\000\002\225\000\000\000\000\000\000\000\000\000\000\005\165\007\002\000\000\005f\005j\005\165\002\225\000\000\005\165\000\000\000\000\000\000\000\000\000\000\002\225\002\225\000\000\015Z\005\165\000\000\005\165\000\000\005\165\000\000\005\165\000\000\000\000\005n\b\022\000\000\000\000\000\000\b.\004V\000\000\000\000\005\165\000\000\002\225\000\000\000\000\000\000\005\165\007n\002\225\000\000\000\000\000\000\000\000\000\000\000\000\005\165\000\000\000\000\005\165\000\000\000\000\004\133\000\000\005\165\005\165\000\238\021\166\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\165\000\000\005\193\005\193\005\165\000\000\003\154\005\193\000\000\000\000\005\193\000\000\000\000\000\000\005\165\005\165\005\165\000\000\005\165\005\165\005\193\000\000\005\193\000\000\005\193\000\000\005\193\000\000\022\022\000\000\000\000\005\165\000\000\000\000\000\000\005\165\016\246\000\000\005\193\000\000\000\000\017\014\000\000\000\000\005\193\005\193\005\165\000\000\000\000\000\000\022\186\022\202\000\000\005\193\000\000\000\000\005\193\000\000\000\000\000\000\000\000\005\193\005\193\005\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\133\005\193\000\000\005\189\007\002\005\193\000\000\000\000\005\189\023\190\000\000\005\189\000\000\000\000\000\000\005\193\005\193\005\193\000\000\005\193\005\193\005\189\000\000\005\189\000\000\005\189\000\000\005\189\000\000\000\000\000\000\000\000\005\193\000\000\000\000\000\000\005\193\000\000\000\000\005\189\000\000\000\000\000\000\000\000\000\000\005\189\007n\007f\000\000\000\000\000\000\000\000\000\000\000\000\005\189\000\000\000\000\005\189\000\000\000\000\000\000\000\000\005\189\005\189\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\189\003:\002\162\000\000\005\189\002f\000\000\006\138\000\000\000\000\002\218\000\000\000\000\000\000\005\189\005\189\005\189\000\000\005\189\005\189\001\210\000\000\006\170\000\000\000\000\000\000\000\000\003>\000\000\000\000\b\198\005\189\000\000\000\000\000\000\005\189\000\000\000\000\000\000\000\000\003J\000\000\000\000\n\146\001\190\000\000\005\189\012\158\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\000\000\n\162\005Z\t\174\000\000\000\000\012\030\000\000\000\000\000\000\b\245\000\000\000\000\000\000\005^\000\000\000\000\t\230\t\254\n\006\t\238\n\014\005f\005j\000\000\000\000\n\170\000\000\000\000\000\000\000\000\n\022\n\030\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n&\n\178\000\000\000\000\n\190\000\000\005n\000\000\000\238\000\000\000\000\000\000\004V\000\000\000\000\000\000\000\000\t\182\t\246\n.\n6\nF\000\000\003=\000\000\000\000\000\000\000\000\003=\nN\001\206\003=\000\000\000\000\000\000\000\000\000\000\000\000\nV\000\000\000\000\003=\000\000\000\000\000\000\003=\000\000\003=\000\000\000\000\000\000\000\000\nv\000\000\n~\n>\000\000\000\000\000\000\003=\000\000\n^\000\000\000\000\000\000\003=\000\000\000\000\001M\nf\nn\000\000\002~\001M\003=\000\000\001M\003=\000\000\000\000\000\000\000\000\003=\003=\003=\000\000\001M\000\000\001M\000\000\001M\000\000\001M\000\000\000\000\000\000\000\000\000\000\003=\003=\000\000\000\000\004~\000\000\001M\000\000\000\000\000\000\000\000\000\000\001M\000\000\003=\003=\001M\000\000\003=\003=\000\000\001M\000\000\000\000\001M\000\000\000\000\000\000\003=\001M\001M\000\238\000\000\001I\000\000\003=\000\000\000\000\001I\001M\003=\001I\000\000\000\000\000\000\001M\003=\000\000\000\000\001M\000\000\001I\000\000\001I\000\000\001I\000\000\001I\000\000\001M\001M\001M\000\000\001M\001M\000\000\000\000\000\000\000\000\001I\000\000\000\000\000\000\001M\000\000\001I\000\000\000\000\000\000\001I\001M\000\000\000\000\000\000\001I\000\000\000\000\001I\000\000\000\000\000\000\001M\001I\001I\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\000\000\000\000\000\000\000\000\000\001I\000\000\000\000\000\000\001I\001\133\000\000\000\000\000\000\000\000\001\133\000\000\012\153\001\133\001I\001I\001I\000\000\001I\001I\000\000\012\153\000\000\001\133\000\000\001\133\000\000\001\133\001I\001\133\000\000\000\000\000\000\000\000\000\000\001I\000\000\000\000\000\000\000\000\000\000\001\133\000\000\000\000\000\000\000\000\001I\001\133\012\153\000\000\000\000\000\000\000\000\000\000\012\153\000\000\000\000\000\000\000\000\001\133\000\000\000\000\000\000\000\000\001\133\001\133\001\133\000\000\000\000\0019\000\000\000\000\000\000\000\000\0019\000\000\000\157\0019\000\000\000\000\001\133\000\000\000\000\000\000\012\153\000\157\000\000\0019\000\000\0019\000\000\0019\000\000\0019\001\133\001\133\001\133\000\000\001\133\001\133\000\000\000\000\000\000\000\000\000\000\0019\000\000\000\000\000\000\000\000\000\000\0019\000\157\000\000\000\000\001\133\000\000\000\000\000\157\000\000\000\000\000\000\000\000\0019\000\000\000\000\001\133\000\000\0019\0019\0019\000\000\001\213\000\000\000\000\000\000\000\000\001\213\000\000\015f\001\213\000\000\002f\000\000\0019\000\000\000\000\000\000\000\157\000\000\001\213\000\000\000\000\000\000\001\213\000\000\001\213\000\000\0019\0019\0019\000\000\0019\0019\000\000\000\000\000\000\000\000\001\213\000\000\000\000\000\000\000\000\000\000\001\213\000\000\000\000\000\000\000\000\0019\015j\000\000\000\000\001\213\000\000\000\000\001\213\000\000\000\000\000\000\0019\001\213\001\213\000\000\015v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\213\000Y\000\000\000\000\001\213\000\000\000Y\000\000\000Y\000\000\000\000\000\000\000\000\005j\001\213\001\213\000\000\000Y\001\213\001\213\000Y\000\000\000\000\000\000\000Y\000Y\000\000\b\145\001\213\000\000\000\000\000\000\000\000\000\000\000\000\001\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000Y\000\000\001\213\000Y\000\000\000\000\000Y\000\000\000\000\000\000\000\000\000Y\000\000\000\000\000\000\000\000\000Y\000Y\000Y\000\000\000\000\000\000\000\000\000\000\000\000\000Y\000Y\000\000\003:\002\162\000\000\000\000\002f\000\000\006\138\000\000\000Y\002\218\000\000\000Y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\210\000Y\006\170\000\000\000Y\000\000\000\000\003>\000\000\b\145\b\198\000\000\000\000\000Y\004Y\007\002\000Y\000\000\t\n\004Y\003J\000\000\004Y\r\138\001\190\000\000\000\000\000\000\000\000\000Y\002\150\000\000\004Y\003\218\000\000\000\000\004Y\003\222\004Y\003\230\000\000\n\162\005Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004Y\000\000\000\000\000\000\005^\000\000\004Y\007n\000\000\000\000\004Y\000\000\005f\005j\000\000\004Y\000\000\000\000\004Y\000\000\000\000\000\000\000\000\004Y\002\198\000\238\000\000\000\000\000\000\000\000\000\000\000\000\004Y\004Y\r\154\000\000\005n\000\000\000\000\004Y\004Y\000\000\004V\004Y\000\000\011\250\000\000\000\000\000\000\000\000\011\250\000\000\000\000\004Y\004Y\000\000\000\000\004Y\004Y\000\000\000\000\t\174\000\000\000\000\000\000\000\000\t\174\004Y\011\254\000\000\000\000\000\000\000\000\012\214\004Y\t\230\t\254\n\006\t\238\n\014\t\230\t\254\n\006\t\238\n\014\004Y\000\000\000\000\000\000\n\022\n\030\000\000\000\000\000\000\n\022\n\030\000\000\000\000\n&\000\000\000\000\000\000\000\000\n&\000\000\000\000\000\238\000\000\000\000\000\000\000\000\000\238\000\000\000\000\000\000\t\182\t\246\n.\n6\nF\t\182\t\246\n.\n6\nF\000\000\000\000\nN\000\000\000\000\000\000\000\000\nN\000\000\000\000\000\000\nV\000\000\0035\000\000\000\000\nV\000\000\0035\000\000\000\000\0035\000\000\000\000\000\000\nv\000\000\n~\n>\000\000\nv\0035\n~\n>\n^\0035\000\000\0035\000\000\n^\000\000\000\000\nf\nn\000\000\000\000\000\000\nf\nn\0035\015~\000\000\000\000\000\000\000\000\0035\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0035\000\000\000\000\0035\000\000\000\000\000\000\000\000\0035\0035\0035\003:\002\162\000\000\000\000\002f\000\000\006\138\000\000\000\000\002\218\000\000\000\000\000\000\0035\000\000\000\000\000\000\0035\000\000\001\210\000\000\006\170\000\000\000\000\000\000\000\000\003>\0035\0035\b\198\000\000\0035\0035\000\000\000\000\000\000\000\000\023&\000\000\003J\000\000\0035\003V\001\190\000\000\000\000\000\000\015\222\0035\002\150\000\000\000\000\003\218\0035\000\000\000\000\003\222\000\000\003\230\0035\n\162\005Z\000\000\000\000\000\000\003:\002\162\000\000\000\000\002f\000\000\006\138\000\000\005^\002\218\000\000\000\000\000\000\000\000\000\000\000\000\005f\005j\000\000\001\210\021\150\006\170\000\000\000\000\000\000\000\000\003>\000\000\000\000\b\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\023\242\003J\005n\000\000\n\146\001\190\000\000\000\000\004V\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\000\000\n\162\005Z\000\000\000\000\000\000\003:\002\162\000\000\000\000\002f\000\000\006\138\000\000\005^\002\218\000\000\000\000\000\000\000\000\000\000\000\000\005f\005j\000\000\001\210\n\170\006\170\000\000\000\000\000\000\000\000\003>\000\000\000\000\b\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\022.\003J\005n\000\000\n\146\001\190\000\000\000\000\004V\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\005\166\n\162\005Z\000\000\000\000\000\000\003:\002\162\000\000\000\000\002f\000\000\000\000\000\000\005^\002\218\000\000\000\000\000\000\000\000\005\170\000\000\005f\005j\000\000\001\210\n\170\000\000\000\000\000\000\000\000\000\000\003>\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\022\142\003J\005n\000\000\003V\001\190\000\000\000\000\004V\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\t\017\000\000\000\000\000\000\000\000\000\000\003:\002\162\000\000\005^\002f\000\000\000\000\000\000\000\000\002\218\000\000\005f\005j\000\000\005\174\000\000\t\017\000\000\000\000\001\210\000\000\000\000\000\000\000\000\000\000\000\000\003>\000\000\000\000\000\000\000\000\000\000\005\250\000\000\000\000\005n\002\225\002\225\000\000\003J\002\225\004V\003V\001\190\000\000\002\225\000\000\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\002\225\003\222\000\000\003\230\005N\000\000\005Z\002\225\000\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\000\000\002\225\000\000\000\000\002\225\002\225\000\000\005f\005j\000\000\005\174\002\225\000\000\000\000\002\225\000\000\000\000\002\225\002\225\000\000\002\225\002\225\000\000\002\225\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005n\000\000\t\017\000\000\002\225\000\000\004V\004A\004A\000\000\000\000\004A\002\225\002\225\000\000\002\225\004A\000\000\000\000\000\000\000\000\000\000\004A\000\000\000\000\000\000\004A\000\000\000\000\000\000\000\000\000\000\000\000\004A\022\222\000\000\002\225\022\246\000\000\000\000\002\225\000\000\002\225\000\000\000\000\000\000\004A\000\000\000\000\004A\004A\000\000\000\000\000\000\000\000\000\000\004A\000\000\000\000\004A\000\000\000\000\000\238\004A\000\000\004A\004A\000\000\004A\0035\000\000\000\000\000\000\0035\0035\000\000\000\000\0035\0035\000\000\004A\0035\000\000\000\000\000\000\000\000\000\000\0035\004A\004A\000\000\0035\000\000\0035\000\000\0035\000\000\0035\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0035\015~\000\000\000\000\0035\015~\0035\004A\000\000\000\000\0035\000\000\000\000\004A\000\000\0035\000\000\000\000\0035\0035\000\000\000\000\0035\0035\0035\0035\000\000\0035\0035\0035\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0035\000\000\000\000\000\000\0035\000\000\000\000\000\000\0035\000\000\000\000\000\000\000\000\000\000\0035\0035\025j\000\000\0035\0035\025\154\000\000\0035\0035\012\145\000\000\000\000\000\000\000\000\012\145\000\000\000\000\012\145\000\000\015\222\0035\000\000\000\000\015\222\0035\0035\000\000\012\145\000\000\0035\000\000\012\145\000\000\012\145\000\000\000\000\000\000\000\000\000\000\004\253\000\000\000\000\000\000\000\000\000\000\012\145\000\000\000\000\000\000\000\000\000\000\012\145\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\145\000\000\000\000\012\145\000\000\000\000\003:\002\162\012\145\012\145\002f\000\000\006\138\000\000\000\000\002\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\145\001\210\000\000\006\170\012\145\000\000\000\000\000\000\003>\000\000\000\000\b\198\000\000\000\000\012\145\012\145\002^\000\000\012\145\012\145\000\000\003J\000\000\000\000\b\242\001\190\000\000\000\000\012\145\000\000\000\000\002\150\026Z\000\000\003\218\012\145\000\000\000\000\003\222\000\000\003\230\000\000\n\162\005Z\005U\000\000\012\145\000\000\000\000\005U\000\000\000\000\005U\000\000\000\000\005^\000\000\000\000\000\000\000\000\000\000\000\000\005U\005f\005j\000\000\005U\000\000\005U\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005U\000\000\000\000\000\000\000\000\000\000\005U\005n\000\000\000\000\000\000\000\000\007\194\004V\000\000\005U\000\000\000\000\005U\000\000\000\000\000\000\000\000\005U\005U\000\238\000\000\005Y\000\000\000\000\000\000\000\000\005Y\000\000\000\000\005Y\000\000\000\000\000\000\005U\005U\000\000\000\000\005U\000\000\005Y\000\000\000\000\000\000\005Y\000\000\005Y\000\000\005U\005U\000\000\000\000\005U\005U\000\000\000\000\000\000\000\000\005Y\000\000\000\000\000\000\000\000\000\000\005Y\000\000\0035\000\000\000\000\005U\007\194\0035\000\000\005Y\0035\000\000\005Y\000\000\000\000\000\000\005U\005Y\005Y\000\238\0035\000\000\000\000\000\000\0035\000\000\0035\000\000\000\000\000\000\000\000\000\000\000\000\005Y\005Y\000\000\000\000\005Y\0035\015~\000\000\000\000\000\000\000\000\0035\000\000\000\000\005Y\005Y\000\000\000\000\005Y\005Y\0035\000\000\000\000\0035\000\000\000\000\000\000\000\000\0035\0035\0035\006\001\000\000\000\000\000\000\005Y\006\001\000\000\000\000\006\001\000\000\000\000\000\000\000\000\0035\000\000\005Y\000\000\0035\006\001\000\000\000\000\000\000\006\001\000\000\006\001\000\000\000\000\0035\0035\017f\000\000\0035\0035\000\000\000\000\000\000\006\001\000\000\000\000\000\000\000\000\000\000\006\001\000\000\000\000\000\000\000\000\015\222\0035\000\000\000\000\006\001\000\000\000\000\006\001\000\000\000\000\000\000\000\000\006\001\006\001\000\238\000\000\000\000\000\000\000\000\000\000\025B\000\000\000\000\000\000\000\000\000\000\003:\002\162\006\001\000\000\002f\000\000\006\001\000\000\000\000\002\218\000\000\000\000\000\000\000\000\000\000\000\000\006\001\006\001\021\"\001\210\006\001\006\001\000\000\000\000\000\000\000\000\003>\001\202\001\206\000\000\006\001\000\000\000\000\000\000\000\000\000\000\000\000\006\001\000\000\003J\000\000\000\000\003V\001\190\000\000\000\000\001\210\001\214\006\001\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\000\000\005\210\000\000\000\000\000\000\001\246\002\134\003:\002\162\005^\002\130\002f\002\150\004\002\004\014\000\000\002\218\005f\005j\004\026\005\174\000\000\000\000\003\226\000\000\000\000\001\210\000\000\000\000\000\000\000\000\000\000\000\000\003>\000\000\000\000\004\030\000\000\000\000\004\209\000\000\005n\000\000\006v\000\000\b\174\003J\004V\000\000\003V\001\190\000\000\000\000\000\000\000\000\025\230\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\006\018\000\000\000\000\000\000\000\000\000\000\003:\002\162\000\000\005^\002f\000\000\000\000\000\000\000\000\002\218\000\000\005f\005j\000\000\005\174\000\000\0066\000\000\000\000\001\210\000\000\000\000\000\000\000\000\000\000\000\000\003>\000\000\000\000\000\000\006\030\000\000\000\000\000\000\000\000\005n\003:\002\162\000\000\003J\002f\004V\003V\001\190\000\000\002\218\000\000\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\001\210\003\222\000\000\003\230\005N\000\000\005Z\003>\000\000\000\000\000\000\000\000\007\129\000\000\000\000\007\129\000\000\000\000\005^\000\000\003J\000\000\000\000\003V\001\190\000\000\005f\005j\000\000\005\174\002\150\007\129\007\129\003\218\007\129\007\129\000\000\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005n\006M\000\000\000\000\005^\007\129\004V\003:\002\162\000\000\000\000\002f\005f\005j\000\000\005\174\002\218\000\000\000\000\000\000\000\000\006M\000\000\007\129\000\000\000\000\001\210\000\000\000\000\000\000\000\000\000\000\000\000\003>\000\000\000\000\005n\011\138\000\000\000\000\000\000\000\000\004V\003:\002\162\000\000\003J\002f\000\000\003V\001\190\000\000\002\218\007\129\000\000\007\129\002\150\000\000\000\000\003\218\000\000\000\000\001\210\003\222\000\000\003\230\005N\005\198\005Z\003>\007\129\007\129\000\000\000\000\000\000\007\129\000\000\007\129\000\000\000\000\005^\007\129\003J\000\000\000\000\003V\001\190\000\000\005f\005j\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\011\150\000\000\000\000\000\000\000\000\005n\003:\002\162\000\000\005^\002f\004V\000\000\000\000\000\000\002\218\000\000\005f\005j\000\000\005\174\000\000\000\000\000\000\000\000\001\210\000\000\000\000\000\000\000\000\000\000\000\000\003>\000\000\000\000\000\000\011\162\000\000\000\000\000\000\000\000\005n\003:\002\162\000\000\003J\002f\004V\003V\001\190\000\000\002\218\000\000\000\000\000\000\002\150\000\000\000\000\003\218\000\000\000\000\001\210\003\222\000\000\003\230\005N\000\000\005Z\003>\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005^\000\000\003J\000\000\000\000\003V\001\190\000\000\005f\005j\000\000\005\174\002\150\000\000\000\000\003\218\000\000\000\000\000\000\003\222\000\000\003\230\005N\000\000\005Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005n\006q\000\000\000\000\005^\000\000\004V\000\000\002\162\000\000\000\000\002f\005f\005j\000\000\005\174\002\218\000\000\000\000\000\000\000\000\006q\000\000\000\000\000\000\000\000\001\210\000\000\000\000\000\000\002\222\000\000\000\000\000\000\000\000\000\000\005n\000\000\000\000\000\000\000\000\002\226\004V\000\000\000\000\000\000\000\000\000\000\000\000\003\022\001\190\000\000\000\000\000\000\000\000\000\000\002\150\000\000\000\000\003\030\000\000\000\000\000\000\007\254\b\002\b\014\000\000\000\000\005Z\000\000\000\000\000\000\006\249\007\002\000\000\000\000\000\000\006\249\000\000\000\000\006\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005f\005j\006\249\000\000\000\000\000\000\006\249\000\000\006\249\000\000\001\181\000\000\000\000\000\000\000\000\001\181\000\000\000\000\001\181\000\000\006\249\000\000\000\000\000\000\005n\b\022\006\249\007n\001\181\b.\004V\000\000\001\181\000\000\001\181\006\249\000\000\000\000\006\249\000\000\000\000\000\000\000\000\006\249\006\249\000\238\001\181\000\000\000\000\000\000\000\000\000\000\001\181\000\000\000\000\000\000\000\000\000\000\000\000\006\249\000\000\001\181\000\000\006\249\001\181\000\000\000\000\000\000\000\000\001\181\001\181\001\181\000\000\006\249\006\249\000\000\000\000\006\249\006\249\000\000\000\000\000\000\000\000\000\000\000\000\001\181\000\000\000\000\001\217\001\181\000\000\000\000\000\000\001\217\006\249\000\000\001\217\000\000\000\000\001\181\001\181\000\000\000\000\001\181\001\181\000\000\001\217\000\000\000\000\017r\001\217\000\000\001\217\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\181\000\000\000\000\000\000\001\217\001\181\000\000\000\000\000\000\000\000\001\217\000\000\000\000\006\005\000\000\000\000\000\000\000\000\006\005\001\217\000\000\006\005\001\217\000\000\000\000\000\000\000\000\001\217\001\217\000\000\000\000\006\005\000\000\000\000\000\000\006\005\000\000\006\005\000\000\000\000\000\000\000\000\000\000\001\217\000\000\000\000\000\000\001\217\000\000\006\005\000\000\000\000\000\000\000\000\000\000\006\005\000\000\001\217\001\217\000\000\000\000\001\217\001\217\000\000\006\005\000\000\000\000\006\005\000\000\000\000\000\000\001\217\006\005\006\005\000\238\000\000\000\000\000\000\001\217\000\000\000\000\000\000\000\000\020\254\000\000\000\000\000\000\000\000\006\005\001\217\012\145\000\000\006\005\000\000\000\000\012\145\000\000\000\000\012\145\000\000\000\000\000\000\006\005\006\005\000\000\000\000\006\005\006\005\012\145\000\000\000\000\000\000\012\145\000\000\012\145\000\000\006\005\000\000\000\000\000\000\004\253\000\000\000\000\006\005\000\000\000\000\012\145\000\000\000\000\000\000\000\000\000\000\012\145\000\000\006\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\145\000\000\000\000\000\000\000\000\012\145\012\145\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012I\000\000\002\162\012I\000\000\027\230\000\000\012\145\000\000\000\000\027\234\000\000\000\000\012I\000\000\000\000\000\000\000\000\000\000\012I\000\000\012\145\012\145\002^\000\000\012\145\012\145\000\000\000\000\000\000\000\000\012I\000\000\000\000\000\000\012\145\000\000\012I\000\000\026\146\000\000\000\000\012\145\001\002\001\190\000\000\012I\000\000\000\000\012I\000\000\000\000\000\000\012\145\012I\004Y\000\000\000\000\000\000\000\000\004Y\000\000\027\238\004Y\000\000\000\000\000\000\000\000\000\000\000\000\012I\000\000\000\000\004Y\012I\000\000\000\000\004Y\000\000\004Y\000\000\000\000\000\000\027\242\012I\012I\000\000\000\000\012I\000\000\000\000\004Y\000\000\000\000\000\000\000\000\000\000\004Y\b1\b1\000\000\000\000\b1\007\194\000\000\012I\004Y\b1\000\000\004Y\000\000\000\000\000\000\016\014\004Y\002\198\000\238\b1\000\000\000\000\000\000\000\000\000\000\000\000\b1\000\000\000\000\000\000\000\000\000\000\004Y\000\000\000\000\000\000\004Y\000\000\000\000\b1\000\000\000\000\b1\b1\000\000\000\000\004Y\004Y\000\000\b1\004Y\004Y\b1\000\000\000\000\000\000\b1\000\000\b1\b1\007.\b1\000\000\000\000\000\000\000\000\001q\004Y\000\000\000\000\000\000\001q\025b\b1\001q\000\000\000\000\000\000\004Y\000\000\000\000\b1\b1\000\000\001q\000\000\001q\000\000\001q\000\000\001q\000\000\000\237\000\000\000\000\000\000\000\000\000\237\000\000\000\000\000\237\000\000\001q\000\000\000\000\b1\000\000\000\000\001q\000\000\000\237\b1\000\000\000\000\000\237\000\000\000\237\000\000\000\000\000\000\001q\000\000\000\000\000\000\000\000\001q\001q\000\238\000\237\000\000\000\000\000\000\000\000\000\000\000\237\000\000\000\000\000\000\000\000\000\000\000\000\001q\000\000\000\237\000\000\000\000\000\237\000\000\000\000\000\000\000\000\000\237\000\237\000\238\000\000\001q\001q\001q\000\000\001q\001q\000\000\000\000\000\000\000\000\000\000\000\000\000\237\000\000\000\000\000\241\000\237\000\000\000\000\000\000\000\241\001q\000\000\000\241\000\000\000\000\000\237\000\237\000\000\000\000\000\237\000\237\001q\000\241\000\000\000\000\000\000\000\241\000\000\000\241\000\000\006\245\000\000\000\000\000\000\000\000\006\245\000\237\000\000\006\245\000\000\000\241\000\000\000\000\000\000\000\000\000\000\000\241\000\237\006\245\000\000\000\000\000\000\006\245\000\000\006\245\000\241\000\000\000\000\000\241\000\000\000\000\000\000\000\000\000\241\000\241\000\238\006\245\000\000\000\000\000\000\000\000\000\000\006\245\000\000\000\000\000\000\000\000\000\000\000\000\000\241\000\000\006\245\000\000\000\241\006\245\000\000\000\000\000\000\000\000\006\245\006\245\000\000\000\000\000\241\000\241\000\000\000\000\000\241\000\241\000\000\000\000\000\000\000\000\000\000\000\000\006\245\000\000\000\000\000\000\006\245\000\000\000\000\000\000\000\000\000\241\000\000\006\201\006\201\000\000\006\245\006\245\016\166\000\000\006\245\006\245\000\241\005\249\000\000\000\000\000\000\000\000\005\249\000\000\000\000\005\249\006\201\006\201\006\201\000\000\000\000\006\245\017F\000\000\000\000\005\249\006\201\000\000\000\000\005\249\000\000\005\249\000\000\005a\007\002\000\000\000\000\000\000\005a\006\201\006\201\005a\000\000\005\249\006\201\000\000\006\201\006\201\006\201\005\249\000\000\005a\000\000\006\201\000\000\005a\000\000\005a\005\249\000\000\000\000\005\249\000\000\000\000\000\000\000\000\005\249\005\249\000\000\005a\006\201\000\000\000\000\000\000\000\000\005a\007n\000\000\000\000\000\000\000\000\000\000\005\249\000\000\000\000\000\000\005\249\005a\000\000\000\000\000\000\000\000\005a\005a\000\238\000\000\005\249\005\249\000\000\000\000\005\249\005\249\000\000\000\000\000\000\000\000\011\249\000\000\005a\000\000\000\000\011\249\000\000\004\202\011\249\000\000\000\000\005\249\000\000\000\000\000\000\000\000\005a\005a\011\249\000\000\005a\005a\011\249\000\000\011\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\249\005a\000\000\000\000\000\000\000\000\011\249\000\000\000\000\000\000\000\000\000\000\000\000\001\202\002b\011\249\000\000\002f\011\249\000\000\000\000\000\000\000\000\011\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\210\001\214\001\230\000\000\000\000\000\000\000\000\011\249\t\162\000\000\001\242\011\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\249\011\249\002n\002v\011\249\011\249\000\000\002\130\000\000\002\150\004\002\004\014\0041\000\000\000\000\000\000\020\214\0041\026>\004)\0041\011\249\000\000\000\000\004)\000\000\000\000\004)\000\000\000\000\0041\000\000\n\134\004\030\0041\000\000\0041\004)\000\000\000\000\000\000\004)\005j\004)\000\000\000\000\000\000\000\000\0041\000\000\000\000\000\000\026J\000\000\0041\004)\000\000\000\000\000\000\000\000\000\000\004)\000\000\0041\000\000\000\000\0041\000\000\000\000\020\234\004)\0041\000\000\004)\000\000\000\000\000\000\000\000\004)\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0041\000\000\000\000\000\000\0041\004I\000\000\004)\000\000\000\000\004I\004)\004\025\004I\0041\0041\000\000\004\025\0041\0041\004\025\004)\004)\004I\000\000\004)\004)\004I\000\000\004I\004\025\000\000\000\000\000\000\004\025\0041\004\025\000\000\000\000\000\000\000\000\004I\004)\000\000\000\000\000\000\016\206\004I\004\025\000\000\000\000\000\000\000\000\019\186\004\025\000\000\004I\000\000\000\000\004I\000\000\000\000\000\000\004\025\004I\000\000\004\025\000\000\000\000\000\000\000\000\004\025\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004I\000\000\000\000\n\194\004I\000\000\000\000\004\025\000\000\001\202\001\206\004\025\000\000\000\000\004I\004I\000\000\000\000\004I\004I\000\000\004\025\004\025\002r\000\000\004\025\004\025\000\000\001\210\001\214\001\230\000\000\000\000\000\000\000\000\004I\000\000\000\000\001\242\000\000\000\000\000\000\004\025\000\000\000\000\001\250\020\154\006\205\006\205\000\000\000\000\001\246\002v\024\018\000\000\000\000\002\130\000\000\002\150\004\002\004\014\000\000\000\000\004\018\000\000\004\026\006\205\006\205\006\205\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\205\000\000\000\000\000\000\000\000\000\000\004\030\000\000\000\000\000\000\000\000\000\000\000\000\006\205\006\205\000\000\000\000\000\000\006\205\000\000\006\205\006\205\006\205\000\000\0049\000\000\000\000\006\205\000\000\0049\000\000\004!\0049\000\000\000\000\015n\004!\000\000\000\000\004!\000\000\000\000\0049\000\000\006\205\000\000\0049\000\000\0049\004!\000\000\000\000\000\000\004!\000\000\004!\000\000\000\000\000\000\000\000\0049\000\000\000\000\000\000\000\000\000\000\0049\004!\000\000\004Q\000\000\000\000\000\000\004!\004Q\000\000\000\000\004Q\0049\000\000\004\006\000\000\006\205\0049\000\000\004!\000\000\004Q\000\000\000\000\004!\004Q\000\000\004Q\000\000\000\000\000\000\000\000\000\000\0049\000\000\000\000\000\000\000\000\000\000\004Q\004!\000\000\000\000\000\000\000\000\004Q\000\000\0049\0049\000\000\000\000\0049\0049\000\000\004!\004!\000\000\004Q\004!\004!\000\000\000\000\004Q\011\014\000\000\000\000\000\000\000\000\0049\001\202\001\206\000\000\000\000\000\000\000\000\004!\000\000\000\000\004Q\017\246\000\000\000\000\000\000\000\000\000\000\003\226\020F\000\000\001\210\001\214\001\230\000\000\004Q\004Q\000\000\000\000\004Q\004Q\001\242\004m\000\000\000\000\000\000\000\000\000\246\000\000\000\000\002\166\000\000\000\000\000\000\001\246\002v\004Q\000\000\000\000\002\130\003\150\002\150\004\002\004\014\004m\000\000\003\154\020\194\004\026\007\149\000\000\000\000\007\149\000\000\000\000\000\000\000\000\000\000\003\158\000\000\000\000\000\000\000\000\000\000\016\146\004\030\000\000\000\000\007\149\007\149\000\000\007\149\007\149\024>\000\000\000\000\016\246\000\000\000\000\000\000\000\000\017\014\000\000\000\000\000\000\007m\000\000\000\000\007m\000\000\000\000\000\000\007\149\000\000\000\000\000\000\000\000\017\022\000\000\000\000\000\000\004R\000\000\004V\007m\007m\000\000\007m\007m\000\000\000\238\017*\017V\000\000\000\000\004m\004m\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007m\000\000\007\153\000\000\021~\007\153\000\000\000\000\000\000\000\000\000\000\000\000\007\149\000\000\007\149\000\000\000\000\000\000\007m\000\000\000\000\007\153\007\153\000\000\007\153\007\153\007\149\000\000\000\000\005\206\007\149\000\000\000\000\000\000\007\149\007\137\007\149\000\000\007\137\000\000\007\149\000\000\000\000\000\000\000\000\007\153\000\000\000\000\007m\000\000\007m\000\000\000\000\000\000\007\137\007\137\000\000\007\137\007\137\000\000\000\000\000\000\007m\000\238\000\000\005\206\007m\000\000\000\000\000\000\007m\000\000\007m\000\000\000\000\000\000\007m\000\000\007\137\000\000\r-\r-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\153\000\000\007\153\000\238\000\000\000\000\r-\r-\r-\007\022\000\000\000\000\000\000\000\000\007\153\000\000\r-\005\206\007\153\000\000\000\000\000\000\007\153\000\000\007\153\001\202\001\206\0222\007\153\r-\r-\000\000\000\000\007\137\r-\007\137\r-\r-\r-\000\000\000\000\000\000\000\000\r-\001\210\002\142\001\230\006\014\000\000\000\000\005\206\007\137\000\000\000\000\001\242\007\137\000\000\007\137\000\000\000\000\r-\007\137\000\000\001\202\001\206\022\146\000\000\001\246\002v\000\000\000\000\000\000\002\130\000\000\002\150\004\002\004\014\000\000\000\000\000\000\000\000\004\026\001\210\002\142\001\230\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\000\000\000\000\246\000\000\004\030\002\166\000\000\000\000\000\000\000\000\000\000\001\246\002v\000\000\000\000\004\141\002\130\000\000\002\150\004\002\004\014\003\154\000\000\000\000\000\000\004\026\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\158\000\000\000\000\000\000\000\000\000\000\016\146\000\000\000\000\004\030\000\000\000\000\000\000\000\000\000\000\024>\000\000\000\000\016\246\000\000\000\000\000\000\000\000\017\014\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\022\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017*\017V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\021~"))
and lhs =
- (8, "\006\005\004\003\002\001\000\194\194\193\193\192\191\191\191\191\191\191\191\191\191\191\191\191\191\191\191\191\191\191\191\191\190\190\189\188\188\188\188\188\188\188\188\187\187\187\187\187\187\187\187\186\186\186\185\185\184\184\183\183\183\182\182\181\181\181\181\181\181\180\180\180\180\180\180\180\180\179\179\179\179\179\179\179\179\178\178\178\178\177\176\176\175\175\175\175\174\174\174\174\174\174\173\173\173\173\173\173\173\172\171\171\171\170\170\169\169\168\168\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\167\166\166\165\164\163\162\161\161\160\160\159\159\159\159\158\158\158\158\157\157\156\156\156\156\155\154\153\153\152\152\151\151\150\149\149\148\147\146\145\144\144\144\143\143\142\142\141\141\141\141\141\140\140\140\140\140\140\140\140\139\139\139\139\139\139\138\138\137\137\137\136\136\135\135\135\134\134\133\133\132\132\131\131\130\130\129\129\128\128\127\127~~}}|||{{{{zzyyxxwwwwwvvvvuuutttttttsssssssrrrrqqpppoonnnnnnnnnmmllkkkkkkkkkkkjiihhgggggfeeddccccccccccccccbbaa```````````````````````````````__^^]]\\\\[[ZZYYXXWWVVUUTTTTTTTTTTTSRQPPPPPPPPPPOOONNNMMMMLLLLLLLLLKKJJJJJIIHHGFEEDDDDDCCBBAAA@@@@@@???>>==<<;;::999887766554433221100//...---,,,+++****)(''''''''''''''''''&&&&&%%%%%%%$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$##\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! \031\031\031\030\030\029\029\029\029\029\029\029\029\029\029\029\029\029\029\029\029\028\028\027\027\026\026\026\026\026\026\026\025\025\025\025\024\024\023\023\023\023\023\022\022\021\021\020\019\019\019\018\018\017\017\017\016\016\015\015\015\015\015\014\014\r\r\r\r\r\012\011\011\n\n\n\t\t\t\b\b\b\b\007\007")
+ (8, "\012\011\n\t\b\007\006\005\004\003\002\001\000\216\216\215\215\214\213\213\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\211\211\210\209\209\209\209\209\209\209\209\208\208\208\208\208\208\208\208\207\207\207\206\206\205\204\204\204\203\203\202\202\202\202\202\202\201\201\201\201\201\201\201\201\200\200\200\200\200\200\200\200\199\199\199\199\198\197\196\196\196\196\195\195\195\195\194\194\194\193\193\193\193\192\191\191\191\190\190\189\189\188\188\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\187\186\186\185\185\184\183\182\181\181\180\180\179\179\179\179\178\178\178\178\177\177\176\176\176\176\175\174\173\173\172\172\171\171\170\169\169\168\167\167\166\165\164\164\164\163\163\162\161\161\161\161\161\160\160\160\160\160\160\160\160\159\159\159\159\159\159\158\158\157\157\157\156\156\155\155\155\154\154\153\153\152\152\151\151\150\150\149\149\148\148\147\147\146\146\145\145\144\144\144\143\143\143\143\142\142\141\141\140\140\139\139\139\139\139\138\138\138\138\137\137\137\136\136\136\136\136\136\136\135\135\135\135\135\135\135\134\134\133\133\132\132\132\132\132\132\131\131\130\130\129\129\128\128\127\127\127~}}}||{{{{{{{{{zzyyxxxxxxxxxxxwvuutttttsrrqqppppppppppppppoonnmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmllkkjjiihhggffeeddccbbaaaaaaaaaaa`_^]\\[ZYXWWWWWWWWWWVVVUUUTTTTSSSSSSSSSRRQQQQQPPOONMLLKKKKKJJIIHHHGGGGGGFFFEEDDCCBBAA@@@??>>==<<;;::9988776655544433322211110/..................-----,,,,,,,+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++**))))))))))))))))))))))(((((((((((((((((((((((((((((((((((((((((((((((((((''&&&%%$$$$$$$$$$$$$$$$##\"\"!!!!!!! \031\031\030\030\030\030\030\029\029\028\027\026\026\026\025\025\024\024\024\023\023\022\022\022\022\021\021\020\019\019\019\019\019\018\017\017\016\016\016\015\015\015\014\014\014\014\r\r")
and goto =
- ((16, "\000\025\0017\000\022\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000*\000\000\000\000\001\136\000h\000&\000\243\002\b\000L\000K\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\165\000\000\000\000\000\000\000\000\000\000\000\131\000\000\000\000\000\000\000<\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000,\250\000\000\000\000\001\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\148\001`\002v\000\203\000\000\002\156\t$\001j\002\210\000\025\000\000\000|\000\000\000Z\002\174\000\000\002X\000\000\000\000\000\000\000\000\000\000\000$\000\000\000\r\003\162\0074\000\000\000\000\000\190\003\148\000\000\000\000\000\b\000\000\001\020\000\000+`\002\216\000\000\002\222\001B\000\000\000\000\003*\003f\000\222\003\016\000&\003\162\004&\001\176\003h\001\128\003f\003\138\t\208\000\000\000\000\005F\003n\004\026\000\173\000\000\000\000\000\000\000\000\000\000\000\000\004F\000\000\005\226\000\000\005F\n\016\000\000\000\000\003\130\004L\003\236\028\242\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\000\000\004.\004^\004\178\000\000\000\000\000\000\000\000\000\191\000\000\000\000\005B\000%\005l\005h\006\194\004\176\004\228\005t\001~\002\168\006\014\029\020\000\000\000\000\005\006\006\018\nD\000\000\029V\004\168\nd\n\164\000\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\224,\252\005\244\000\000\n\168\006 \000\000\011<\029r\000Q\000\000\011L\005\202\000\000\000\000\000\000\006T\000\000\004\228\000\000\006J\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\018\002\030\000\000\000\000\001\160\000\000\r\230\000\000\001\018\005@\001\018\000\000\000\000\000\000\000\000\000\000\029\174\000\000\006\030\006\176\000\000\021\170\006D\006\246\000\000\000\000\000\000\006J\000\000\000\000\000\000\000\000\003\130\000\000\000\000\000\000\000\000\000\000\011\166\000\000\000\000\000\000\000\000\000\000\000\000\004f\006\228\000\000\000\000\000\000\003\130\007<\029\234\006\178\006T-(\000\000\001\190\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001,\000\000\000\000\000\000\000\000\007\208\029\252\000\000\000\000\006\214\006h\030\156\000\000\000\000\000\000\030\190\006\212\030\208\000\000\006\212\000\000\030\220\006\212\000\000\031B\006\212\006\212\000\000\000\000\006\212\000\000\000\000\031v\000\000\006\212\031\166\000\000\006\212\bz\000\000\000\000\n\164\000\000\000\000\000\000\000\000\006\212\011\148\000\000\000\000\000\000\006\212\000\000\001z\007\234\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\n\000\000\007\178\000\000-X\003\130\000\000\000\000\000\000\000\000\007\208\bJ\011\240\007\200\b.\b6\006z\004\240\006\188\000G\b\172\000\000\000\000\000I\000?\006\196\000f\b\162\001\158\000\000\000e\000\230\003R\002\230\t\254\000\000\000\000\019\"\000\0001\234\t\164\000\000-d\003\130-\160\003\130\000\000\tV\000\000\tx\000\000\000\000\t\140\000\000\000\000\000\000\nf\000\000\001\220\000e\000\000\000\000\tL\000\000\000\000\000\000\000\000\000\000\000\000\000e\000\000\000\000\000e\000\000\b\162\005\\\000\000\000}\002\168\000\000\000}\000\000\000\000\002v\000e\000\000\000\000\000\000\000\000\000\000\000\000\000}\012 \012H\nf\n8\031\176\015\144\000\000\t\232\007\020\012\148\n\004\0070\nl\027\002\000\000\000\000\000\000\000\000\000\000\0118\b\128\000\000\000\000\000\000\n\016\007b\006*\000}\003\210\000\000\000e\000\000\000\000\000\000\004\168\000\000-\194\003\130\012\238\n\024\007n\012\244\n4\007\196\002\250\r\186\006\212\rH\n<\007\216,<\n\244\000\000\003n\006\212.D\003\130\n\248\000\000\000\000\000\000\000\000\000\144\n\234\n\250\000\000\000\000\007|\rh\n\130\b& \n\006\212\r\168\n\134\bH\027<\000\000&B\000\000\000\000\014\b\031\232\0246\000\000\000\000\000\000\000\000)\004\000\000\000\000\000\000\004\150\014f\000\000\000\000\000\000\000\000 L,\208\000\000\000\000\000\000\000\000\n|\014\194\000\000\n\154 \170\n\154 \176\n\154\000\0000\232\000\000 \216\n\154\014\242\003\152\015 \000\000\000\000!\000\n\154!\b\n\154!d\n\154!\190\n\154!\200\n\154\" \n\154\"N\n\154\"|\n\154\"\172\n\154#\002\n\154# \n\154#v\n\154#\166\n\154#\196\n\154#\214\n\154$\006\n\154$z\n\154$\170\n\154%\n\n\154%:\n\154\bn\006\002\002\004\000\144\011L\000\000\000\130.n\000\000\015~\000\000.^\000\000\003\130\003x\000\000\003\130.h\003\130\000\000\015\172\000\000\000\000\000\000\015\236\000\000\000\000\000\000\000\000\000\000\006\212\000\000\000\000.\198\000\000\003\130\000\000\000\000\003x\011R\000\000.\208\003\130\016\006\000\000\000\000\n\246\000\000.\210\003\130\016H\000\000\000\000\016|\000\000\000\000\000\000/$\003\130\016\158\000\000\n\218\016\224\000\000%\\\000\000\006\212%\150\000\000\006\212%\252\000\000\006\212\012@\000\000\000\000\000\000\000\000\000\000&&\006\212\005V\006\176\000\000\000\000\000\000\n\154\017\004\000\000\000\000\000\000&\004\n\154\000\000\000\000\000\000\000\000\017T\000\000\000\000\000\000\n\154\017\194\000\000\018\020\000\000\000\000\000\000\018`\000\000\000\000\000\000\000\0001\136\000\000\000\000\018h\000\000\000\000\000\000&\148\n\154\018\156\000\000\000\000\000\000&\204\n\154\018\248\000\000\000\000&\238\n\154\n\154\000\000\006n\019l\000\000\000\000'\028\n\154\019\186\000\000\000\000'\\\n\154't\n\154\000\000'\172\n\154\000\000\000\000\019\210\000\000\000\000(6\n\154\020\020\000\000\000\000(<\n\154\020,\000\000\000\000(t\n\154\000\000(\146\n\154\000\000\0038\000\000\000\000\n\154\000\000\000\000\020x\000\000\000\000\020\160\000\000\000\000\011,\000\000\000\000\020\238\000\000\021,\000\000\000\000\000\000\000\144\011\194\000\000)&\006\174\001\018\021L\000\000*(\000\000\000\000\000\000*p\000\000\000\000\021\212\000\000\022\002\000\000\000\000\000\000\000\000\022$\000\000\000\000\000\000(\198\n\154(\212\n\154\000\000\n\218\022d\000\000\000\000\022\196\000\000\023\030\000\000\000\000\027\002\000\000\000\000\000\000\0238\000\000\000\000\000\000\000\000\023l\000\000\000\000\000\000\000\000\0128\000\000\000\000\000\000,N\000\000\002\024\000\000\002\190\000\000\011\228\000\000\002H\000\000\000\000\000\000\000\000\000\000\000\000\0118\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\154\000\000\012@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bx\006\142\000}\023\140\000\000\011v\b\164\011\234\001\186\006\154\000}\003\218\000e\b\130\000}\000\000\023\174\000\000\003\174\000\000\011|\b\200\011z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\194\002V\000\207\000\000\000\000\000\000,T\000\0001\242\000\000\tZ\000\000\tf\000\000\000\000\000\000\000\000\001Z\000\000\000\000\000\000\b\198\001\018\000\000\001\018\004\146\000\000\nN\001\018\001\018\t\162\000\000\023\222\000\000\t\230\012\144\000\000\024\136\006\240\000\000\000\000\000\000\000\000\000\000\000\000\n\154\000\000\007b\000\000\n\154\000\000\000\000\004T\000\000\000e\000\000\0058\000\000\000e\000\000\005B\000e\000\000\000}\000\000\n\022\b\138\000a\000\000\011\204\011\248\n6\012\024\012\176\005\138\000e\006\244\000\000\n@\012\196\012\210\006\188\007\228\012\190\nz\012\238\006\212\b\180\012\214\000\000\000\000\0072\tt\000\000\0066\002\156)\182\006\212\024\018\000\000\b\014\002\218\012\154\n\150\b\244\000\186\000\000\012\192\n\164\014\000\000\000/0\003\130\rn\r\168\000\000\t\148\000\000\r*\n\188\r\"\rH\002p\000\000\000\000\000\000\000\000\000\000\n\192\t\166\000\000\n\212\t\190\000\000\006\248\017\244\rN\rT\n\226\r\196\t\214\000\000\n\232\r\198\n(\000\000\r`\n\240\r\222\000\000\r\218\000\000\nh\000\000\r\230\000\000\007\128\000e\r\194\011\000\r\244\000\000\007\130\002\130\r\206\000\000\000\000\003l\014\006\n~\000\000\007\208\000e\n\240\000\000\003\246\000\000\r\162\011\n\t\242\002\188\000\000\r\168\011\026\r\156\rH\r\176\r\178\011\"\014\242\000\000\r\216\001\182\000\000\000\000\000\000\000\000\000\206\011,\r\178/B\003\130\000\000\000\181\011F\014R\000\000\000\000\000\000\000\000\000\000\000\000/N\003\130\000\000\011V\014\158\000\000\000\000\000\000\000\000\000\000\000\000\017\014\000\000/\160\003\130\011\178\000\000\003\130\011Z\002(\000\000\000\000\011l\011\162\014R\000\000\0030,\146\000\000\002\178\000\000\000\000\000\000\000\000/\254\003\130\003\130\000\000\000\000\0042\000\000\014T\000\000\b \0042\0042\000\000\011\168,d\003\1300\n\003\130\011\180\000\000\000\000\000\000\000\000\011\224\000\000\000\000\000\130\000\000\005F\0142\011\180\015*\014\b\000\000\000\000\t6\005\232\014F\000\000\000\000\011\182\0158\014,\000\000\000\000%n\000\000\001\218\000\000'\156\024:\003\130\000\000/\148\003\184\000\0000^\000\000\000\000\000\000\000\000\000\000\0042\000\000\000\000\011\240\014h\011\184\015`\0146\000\000\000\0000z\012R\014t\000\000\000\000\000\000 T\000\000\000\000\000\000\000\000\000\000\000\000\012n\000\000\014\130\011\198\004L\000\000\015X\015\n\012r\014\138\000\000\000\000\014\148\011\228\004\228\000\000\000\000\007\182\029r\003\014\000\000\000\000\000\000\0146\014\\\012\b\000\000\014`\0146\000\000\015\028\012\144\014\162\000\000\000\000\000\000\003\130\005t\005\254\tp\000\000\000\000\000\000\000\000\014h\012\014\000\000\n(\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\130\014V\012\026\015\144\014h\000\000*\140\000F\012 \014D\003\248\0004\0128\014\232\000\000\015\140\024\226\000\000\000\000\025\018\000\000\012\196\000\000\004\150\000\000\000\000\000\000\000\000\000\000\000\0000\028\003\130\000\000\015\142\025:\000\000\000\000\025j\000\000\002\\\012T\015B\000\000\000\000\019H%V\015\004\000\0000\198\003\130\025\136\000\000\000\000\025\224\000\000\000\000\012\226\000\000\005\208\000\000\000\000\000\000\000\000\000\000\000\000*\186\000\000\000\000+2*\226\015\006\000\0000\228\003\130\026\002\000\000\000\000\026Z\000\000\000\000\012X\026\136\012\234\000\000\012Z\012r\001\150\004\166\012|\b\238\012\152\015T\026\172\012\254\000\000\012\174\012\180\014\250\000\000\007\240,\214\000\000\007&\000\000\012\182+N+\\\br\014n\t4\000\0001\026\0038\000\000\005\160\000\000\000\000\005\160\000\000\000\000\005\160\015\016\000\000\011\142\005\160\015p\0270\r\000\000\000\005\160\000\000\000\0001\"\000\000\000\000\000\000\005\160\000\000\000\000\r\\\000\000\r\250\b\140\rf\000\000\012\184,\226\r\128\000\000\000\000\000\000\000\000\r\142\000\000\000\000\004X\000\000\005\1601B\000\000\014x\005\160+\150\000\000\r\146\014\238\012\232\015\228\014\186\000\000,\b\r\148\014\244\000\000\000\000\000\000#\216\007\200\000\000\000\000\000\000\000\000\000\000\000\000\n|\r\158\000\000\015\006\000\000\000\000\000\000\000\000\r\182)\164\000\000\000\000\000\000\000\000\n|\000\000\000\000\r\216)\250\000\000\000\000\000\000\000\000\000\000\000}\000e\000\000\000\000\006\212\000\0001Z\003\130\000\000\005\246\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\188\r\026\n\030\000}\000\000\nV\000\000\000e\000\000\015\228\000\000\000\000\000\000\000\000\000\000\b\176\000\000\000\000\000\000\000\000\000\000\000\000\015\140\000e\014\188\014\\\b$\r:\000\000\001\"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014h\b\208\r^\000\000\007\252\015\242\015\170\r\224\000\000\000\000\015\158\000%\003\142\000\000\000\000\000\000\rh\000\000\rl\001\026\000\000\000\000\001\018\001D\000\000\000\000\000\000\000\000\000\000\014\254\000\000\000\000\n&\007\168\000\000\000\0001\196\003\130\003\130\000\0001\208\003\130\011(\000\000\000\000\000\000\003\130\000\000\000\000\007\218\015\176\014H\000\000\000\000\015\164\007L\0016\000\000\000\000\000\000\000\000\n4\015\242\bb\015\198\014V\000\000\000\000\015\186\b\242\005\\\000\000\000\000\000\000\000\000\000e\000\000\005\248\000\000\000\000\000\000\027J\000\000\027b\000\000\000\000\000\000\000\000\000\000\b\206\000\000\000\000\000\000\t\144\000\000\003\130\000\000\tp\000\000\000\000\000\000\028$\006\212\000\000\000\000\004\014\015$\001p\000\000\000\000\000\000\000\000\000\000\000\000\0118\000\000\000\000\000\000\000\000)b\000\000\014b\000\000\000\000\000\000\000\000\004L\005\166\027\230\028\026\000\000\000\000\014r\028\150\000\000\000\000\000\000\014\132\028\194\000\000\000\000\000\000\000\000"), (16, "\006\016\003\223\002\b\002\t\001\187\000\139\006\179\006\165\001\204\002\238\001\187\000;\0062\001\219\006`\006\157\002L\006\017\006\190\001\219\006\019\002\238\001\245\002\238\002M\001\014\001\232\000\189\006\132\006\020\006!\006\016\004\229\002\b\002\t\000\139\001\245\002[\000\148\005v\006X\003\234\003\236\003\238\0007\000?\006t\002L\006\017\006 \001\223\006\019\001\017\000q\0007\002M\001\223\004\232\006\021\000m\006\020\006!\000\139\004\027\001\224\000\144\001\234\000\\\002[\001\187\001\224\001\230\004\234\000\189\001\187\004y\001\227\004\031\001\219\000\139\001[\000\149\001\204\001\219\000`\0007\006\022\001[\002\175\006\021\002]\004\235\0061\006\183\006\023\001\247\002\178\000\145\000\193\001\\\002\179\002\012\001^\001_\006d\006e\001\\\001l\001\019\001^\001_\006&\001\185\006f\006g\001\223\001\014\006\022\001\019\001\015\001\223\002]\001\226\001\212\006h\006\023\006'\001\246\000\139\001\224\006l\001\204\002\012\001\019\001\224\006\026\006d\006e\006\192\001\218\006\028\001\246\006&\001\017\001\n\006f\006g\001\248\000\189\001m\006\030\001n\002\186\002_\005x\002e\006h\006'\001 \001\014\005A\002k\001\014\002a\002\238\006\031\006\026\001c\000m\001\028\001\213\006\028\005\205\006\016\001u\002\b\002\t\001\245\001d\000d\001!\006\030\002m\001\014\002_\001d\002e\004\236\001a\002L\006\017\006 \002k\006\019\002a\001%\006\031\002M\006\216\002\t\005\207\000:\006\020\006!\006\016\002\180\002\b\002\t\001\226\001\019\002[\0009\004\232\002m\005\208\000\194\002\238\004\205\004E\005\210\002L\006\017\006 \005\254\006\019\002\182\002\238\004\234\002M\001\014\001w\006\021\001\"\006\020\006!\006v\000\139\001w\001\146\000\144\001b\002[\000=\000\250\001W\001x\004\235\001b\000\253\005H\005I\001\019\001\019\0015\006\130\001\019\001\017\006}\001\014\006\022\001\028\005\001\006\021\002]\006\150\006\151\006U\006\023\004\212\005R\006a\004\156\001\000\001[\002\012\001\234\001\019\003\223\006\128\004\213\006\161\002\208\001\246\004\237\006&\001\017\001%\002\238\001?\002\211\006\022\000x\001\\\002\179\002]\001^\001_\006\217\006\023\006'\006b\004\026\000\250\001\028\001\247\002\012\001\028\001\153\006\026\006c\006\162\003\154\001\187\006\028\001\188\006&\000\189\003\237\003\236\003\238\001\014\001\219\001\019\006\030\006\185\001b\002_\001\028\002e\006~\006'\001\000\006~\003\204\002k\003\160\002a\001\019\006\031\006\026\005\205\006W\000\127\001\187\006\028\001\217\006\016\000\133\002\b\002\t\003\239\001\019\001\219\006~\006\030\002m\001\248\002_\001\223\002e\001c\000\143\002L\006\017\006 \002k\006\019\002a\005\207\006\031\002M\001d\001\224\001\028\003\156\006\020\006!\006\016\003\207\002\b\002\t\000\250\005\208\002[\000\189\000\194\002m\005\210\000@\001\223\004\205\005\233\002\238\002L\006\017\006 \001[\006\019\002\180\001%\0007\002M\001\028\001\224\006\021\000\250\006\020\006!\006(\000\139\003\155\000\173\001\204\001\019\002[\001\\\001l\005\153\001^\001_\001\187\002\238\001\242\001w\001\234\004X\002\b\002\t\001%\001\219\005\155\001\146\006\022\001b\003\155\006\021\002]\003\157\003r\006$\006\023\004\212\000\139\000\128\001\191\001\204\004\127\002\012\003G\000\194\001\238\000\142\004\213\001\247\001[\001\031\004\220\006&\001m\004\205\001n\002(\000\131\006\022\001\028\001\014\001\223\002]\001\015\0007\003\242\006\023\006'\001\\\001l\004\144\001^\001_\002\012\001\014\001\224\006\026\001\015\001u\000\250\004[\006\028\000\175\006&\000\134\003\243\000\194\001\017\0007\001d\003\223\006\030\001\014\003u\002_\005\b\002e\002\201\006'\000\194\001\248\001\017\002k\006\135\002a\001\218\006\031\006\026\001\192\002\011\000\164\001m\006\028\001n\0020\002\238\004\208\004\205\000\194\001\017\002\012\002\238\006\030\002m\001!\002_\006\016\002e\002\b\002\t\005:\003\236\003\238\002k\001\218\002a\001u\006\031\001!\006\220\006\221\001w\002L\006\223\004\136\000\194\006\019\001d\003I\001x\002M\001b\000\166\001\019\002m\006\020\006\225\006\016\000\171\002\b\002\t\006\240\000\139\002[\005+\001\204\000\170\001\019\004\212\004\177\0023\006\232\002_\002L\006\233\006u\000\181\006\019\003\208\004\213\002`\002M\002a\004\214\006\021\001\019\006\020\006\241\000\176\001\187\004\138\002\024\005}\001\187\002[\003\201\000\180\0015\001\219\001w\000\186\001\014\001\219\002\238\001\028\006b\001\158\001x\002\172\001b\000\203\0015\006\022\004\139\006c\006\021\002]\001K\001\028\000\194\006\023\000\178\006\142\003\207\005\246\001\\\002\029\002\012\001^\001_\001%\003\239\001?\001>\006\228\001\223\001\028\000\194\000\139\001\223\0055\001\204\001\014\006\022\001%\002q\001?\002]\000\187\001\224\005\249\006\023\006'\001\224\001\187\001[\004\017\004\221\002\012\004\138\001N\006\026\001%\001\219\006\245\005\251\006\028\003|\002\233\002\234\000\195\004\007\005\253\000\204\001\\\002\179\006\030\001^\001_\002_\006:\002e\000\217\006'\002\b\002\t\005\129\002k\001\014\002a\005\252\006\031\006\026\001u\001\019\002\251\000\216\006\028\005\249\006\016\001\223\002\b\002\t\000\189\001d\000\220\006B\006\030\002m\000\194\002_\001\234\002e\005\251\001\224\002L\006\017\006.\002k\006\019\002a\004\215\006\031\002M\003\012\003\127\003\132\005\205\006\020\006!\006\016\000\194\002\b\002\t\000\194\001\019\002[\001\249\005\252\002m\001\247\002\238\001c\000\194\006\232\001\028\002L\006\233\005\160\002\238\006\019\003\245\002\238\001d\002M\005\207\001w\006\021\005A\006\020\006\236\004\028\002\b\002\t\001x\001\234\001b\002[\001\187\005\208\004\021\003\248\002\011\001\187\005\210\004\024\002L\001\219\005\226\002\158\002\180\001\019\001\219\002\012\002M\006\022\001\028\000\232\006\021\002]\006L\001\235\001\248\006\023\001\247\004\238\000\226\002[\002\212\001l\002\012\001^\001_\002\240\000\240\001w\006\175\005\236\005\164\001\187\006&\004&\001\029\001\146\001\223\001b\006\022\000\228\001\219\001\223\002]\000\233\002\238\0007\006\023\006'\001\014\005A\001\224\001\015\002\238\002\012\001\028\001\224\006\026\002_\006\162\006\239\001P\006\028\002\217\002\233\002\234\002`\000m\002a\001\248\005H\005I\006\030\002]\001\004\002_\001\017\002e\001\223\006'\000\194\001'\004\215\002k\002\012\002a\005Y\006\031\006\026\001u\005R\001\234\001\224\006\028\001\014\006\016\001\007\002\b\002\t\004\246\001d\000\194\006;\006\030\002m\000\194\002_\006\182\002e\002b\001\r\002L\006\017\001!\002k\006\019\002a\002\021\006\031\002M\001\247\000\236\005\030\000\241\006\020\006*\002\237\005\212\005\249\001<\001\014\001\014\002[\001\015\001\015\002m\002_\001\022\002e\005H\005I\001\234\001\019\005\251\002k\002\238\002a\001\234\001:\005\031\005_\005 \001w\006\021\0033\005Q\001T\001\017\001\017\005R\001x\001\014\001b\004\215\001\015\002m\001k\003\191\005\252\0012\001\247\001>\001\248\003\199\0019\001\175\001\247\002\238\001[\002\238\005!\006\022\000\194\003D\000\194\002]\001(\001\019\001\017\006\023\000\194\001[\004-\001\028\001!\001!\002\012\001\\\001l\002\239\001^\001_\001M\004:\0042\005A\006-\005\"\001\177\000\194\001\\\002\179\001\184\001^\001_\006\160\005#\000\194\005$\001%\004\011\006'\001\248\001\019\001\019\001!\001\014\000\194\001\248\001\015\006\026\004\002\001\148\004(\005`\006\028\000\194\003\207\001\028\006\152\001m\001S\001n\002(\001\014\006\030\000\189\001\015\002_\003\207\002e\0047\002\003\001\017\001\019\001\145\002k\005&\002a\001j\006\031\006q\005(\0052\003b\001u\002\006\0015\0015\000\194\005A\001\017\005\\\000\194\001\028\001\028\001d\002m\001c\005a\003u\001t\0007\001\187\001\187\004x\004~\005]\005A\001d\001!\002\020\001\219\001\219\005H\005I\003\207\002#\0015\002\238\001%\001%\0016\001?\005D\001\028\006\163\006\164\001!\005J\005Z\000\189\001\014\000\194\005R\001\015\003e\005\200\001\136\001\019\002\b\002\t\006\154\001\187\001\152\004\135\005R\000\194\001w\001\223\001\223\001%\001\219\001?\002L\003h\001x\001\019\001b\001\017\002&\001w\002M\001\224\001\224\001[\001\164\000\189\003\134\001\146\002,\001b\000\194\004.\001\019\002[\005A\005\030\000\194\005H\005I\001\169\001\014\0015\001\\\001l\004\004\001^\001_\001\223\001\028\005\205\004\205\004X\005J\005Z\001!\005H\005I\005R\003\253\0015\006\138\001\224\005\031\006\194\005 \006T\001\028\002A\006\168\001\234\005J\005Z\0007\001\234\001%\005R\001?\005\207\005\030\000\194\000m\002\238\005\240\001\019\002F\001m\002]\001n\002(\000\194\000\189\005\208\001%\005!\001?\003\203\005\210\002\012\001\247\004\030\005\217\004\212\001\247\002\157\006\174\005\031\006\176\005 \003\190\003\189\001u\006^\004\213\001\174\005\205\001\180\004\219\004@\002\b\002\t\005\"\001d\002b\005H\005I\003u\001\234\0015\000\194\005#\003\196\005$\002L\001\019\001\028\0043\005!\004X\005J\005Z\002M\001\014\005\207\005R\001\015\000\194\006\202\005`\003\211\002_\001\248\002e\004D\002[\001\248\001\247\005\208\002k\001\225\002a\001%\005\210\001?\005\"\000\194\005\214\002\b\002\t\001\017\000\194\005&\006\196\005#\001w\005$\005(\0052\002\238\002m\005\212\002L\001x\001\197\001b\001\028\005\\\006\204\000\189\002M\004\205\005`\000\194\001\199\002\238\006Q\006\163\006\164\006j\002\b\002\t\005]\002[\002\238\006\198\001\206\001!\002]\001\248\003\223\000\194\003\241\005\205\002L\005&\002\238\005R\006\139\002\012\005(\0052\002M\003\230\001\208\006\171\002\b\002\t\002\238\003\232\005\\\005\187\006?\0048\001\211\002[\001\019\001\215\001\014\001\222\002L\005\207\004\212\001[\002b\005]\002\b\002\t\002M\004P\005N\003\236\003\238\004\213\004\t\005\208\002]\004\245\004]\003\250\005\210\002[\001\\\001l\005\211\001^\001_\002\012\003\169\002\238\004`\002_\001\155\002e\003\182\001[\001\187\001\234\004\143\002k\0015\002a\004h\001\014\000\194\001\219\001\015\001\028\002]\001)\000\194\006\199\002b\003\254\001\\\001l\003\178\001^\001_\002\012\002m\002\238\003\223\006F\001\139\001m\001\247\001n\001\142\001*\001\017\001\019\002\238\001%\002]\001?\001H\004\029\001\019\002_\000\194\002e\001\223\004l\002b\002\012\001\187\002k\006J\002a\001u\001\019\002\002\004#\002\011\001\219\001\224\001m\004*\001n\001\142\001d\005V\003\236\003\238\002\012\002\005\001!\002m\003\168\002b\002_\002\019\003\001\000\194\004t\002\"\001\014\001\248\002k\001\015\002a\001u\001)\001/\001\014\004\133\0040\001\015\002\238\002%\001)\001\223\001d\002+\0027\001\019\002_\000\194\002e\002m\004C\001\028\001*\001\017\002k\001\224\002a\004H\0024\001F\001*\001\017\001w\000\194\001[\002<\002_\001+\000\194\004S\001x\004\\\001b\002;\002`\002m\002a\003\247\002@\001\014\002E\004_\001\015\001\\\001l\001)\001^\001_\004f\0015\001!\004j\004\137\001\144\001w\004o\001\028\000\194\001!\003\223\001=\002\241\001x\004{\001b\001*\001\017\001/\004\142\002\b\002\t\000\194\001D\002j\002\161\001/\004\147\002\196\000\194\001\019\004\152\002\203\001%\002L\001?\004\162\001m\001\019\001n\001\142\000\194\002M\000\194\002\b\002\t\002\238\002\238\004\003\004\168\006\147\003\236\003\238\000\194\001!\002[\002\232\004\179\002L\004\194\000\194\002\231\001u\000\194\002\b\002\t\002M\000\194\004\216\002\238\000\189\001/\003\188\001d\0015\000\194\003W\002\238\002L\002[\000\194\001\028\0015\001\019\003_\001=\002M\003\148\000\194\001\028\003\158\003\180\000\194\001=\005\205\004\199\003\185\000\194\004\223\002[\004\191\004\228\002\b\002\t\004\240\004\250\005\021\001%\002]\001?\000\194\003\195\003\197\005*\003\210\001%\002L\001?\000\194\002\012\000\194\003\219\005\207\004\233\002M\001w\002\238\0015\0054\000\194\003\171\005\019\002]\001x\001\028\001b\005\208\002[\001=\003\249\002\238\005\210\002\238\002\012\002b\005\221\005@\002\b\002\t\005T\002\b\002\t\002]\004\000\004)\005d\000\194\002\238\005j\000\194\001%\002L\001?\002\012\002L\000\194\000\194\000\194\002b\002M\005n\002_\002M\002e\000\194\003{\004\"\004$\003v\002k\005\027\002a\002[\002\238\005\138\002[\005\178\005\238\002b\000\194\002]\004'\002\b\002\t\005'\002_\005/\002e\002\238\005\183\002m\002\012\002\238\002k\005\222\002a\002L\000\194\002\b\002\t\000\194\005F\002\238\002\238\002M\002_\000\194\003\001\005\188\000\194\003k\0046\002L\002k\002m\002a\002b\002[\004,\005\218\002M\000\194\005\194\005\202\005\243\002]\003\\\005w\002]\0045\002\b\002\t\0041\002[\002m\000\194\002\012\000\194\000\194\002\012\001[\0044\005\154\002_\002L\002e\005\180\004B\006\b\002\238\000\194\002k\002M\002a\002\238\000\194\005\191\005\225\003T\001\\\001l\002b\001^\001_\002b\002[\004G\002\238\001\014\000\194\002]\001\015\002m\006E\002\238\004I\002\238\002\238\002\b\002\t\000\194\002\012\002\238\000\194\000\194\000\194\002]\004O\002_\006_\002e\002_\002L\002e\002\238\001\017\002k\002\012\002a\002k\002M\002a\001m\005\237\001n\002(\002b\006k\005\241\000\194\003L\002\238\006y\002[\006{\002\238\004N\002m\002]\004R\002m\005\245\002b\004T\004^\002\b\002\t\001u\005\250\002\012\006\006\006\r\001!\002_\000\194\002e\006\027\004i\001d\002L\004e\002k\003q\002a\004g\004k\004n\002M\006\"\002_\000\194\002e\004\130\002X\002b\004s\004v\002k\004\129\002a\002[\001\019\002m\004|\004\128\006+\002]\002\238\000\194\006p\000\189\002\b\002\t\000\194\002\238\000\194\004\132\002\012\002m\004\141\002\238\002_\004\146\002e\004\148\002L\004\249\004\151\002\238\002k\001w\002a\004\154\002M\005\205\002\b\002\t\002\238\001x\002d\001b\004\158\002b\004\166\004\173\001$\002[\004\184\001\014\002L\002m\001\015\001\028\002]\004\200\004\217\004\248\002M\002\b\002\t\004\241\006\156\005\207\002s\002\012\004\242\004\247\004\251\006\170\002_\002[\003\001\002L\000\189\006\226\001\017\005\208\002k\001%\002a\002M\005\210\006\237\004\252\005\029\005\239\002r\005\022\005\023\002b\005\028\006\242\0051\002[\005-\005.\0050\005\205\002m\002]\005[\005>\005?\005C\005E\002\b\002\t\005G\005S\005c\002\012\005e\001!\005f\002\b\002\t\002_\005k\002e\002L\005o\005s\005\133\002]\002k\005\207\002a\002M\002\b\002\t\005\140\005\144\005\168\002\166\002\012\002b\003\152\005\189\005\195\005\208\002[\001\019\002L\003\161\005\210\002m\002]\005\213\006\002\005\219\002M\005\223\006\015\006\t\006\n\006\014\002\177\002\012\006\029\002b\006D\001[\002_\002[\002e\006O\003\174\006Z\006\\\002\175\002k\006n\002a\002\b\002\t\006o\006s\002\178\006\155\006\159\001\\\002\179\002b\001^\001_\006\134\002_\002L\002e\006\169\006\173\002m\001\028\002]\002k\002M\002a\006\211\000\000\000\000\000\000\002\200\002\011\000\000\002\012\000\000\002\b\002\t\002[\002_\000\000\002e\000\000\003\165\000\000\002m\002]\002k\001%\002a\002L\000\000\000\000\000\000\000\000\000\000\000\000\002\012\002M\002b\000\000\000\000\002\b\002\t\002\207\000\000\000\000\000\000\002m\000\000\000\000\002[\003\155\000\000\000\000\000\000\002L\000\000\001c\002\b\002\t\000\000\002b\000\000\002M\000\000\002_\000\000\002e\001d\002\210\002]\000\000\002L\002k\002_\002a\002[\000\000\000\000\000\000\002M\002\012\002`\000\000\002a\000\000\002\216\000\000\002_\000\000\002e\002\b\002\t\002[\002m\002\180\002k\000\000\002a\000\000\000\000\000\000\000\000\002]\000\000\002L\002b\000\000\000\000\002\b\002\t\000\000\000\000\002M\002\012\002\181\000\000\002m\000\000\002\219\001w\001\014\000\000\002L\001\015\000\000\002[\000\000\001\146\002]\001b\002M\000\000\002_\000\000\002e\000\000\002\244\000\000\002b\002\012\002k\000\000\002a\002[\000\000\002]\000\000\001\017\002\b\002\t\000\000\000\000\000\000\000\000\000\000\000\000\002\012\004\187\000\000\000\000\000\000\002m\002L\000\000\002b\002_\000\000\002e\000\000\000\000\002M\000\000\004\190\002k\000\000\002a\000\000\000\000\002]\000\000\002\254\002b\000\000\002[\001!\000\000\000\000\000\000\000\000\002\012\000\000\002_\000\000\002e\002m\000\000\002]\000\000\000\000\002k\000\000\002a\000\000\002\b\002\t\000\000\000\000\002\012\002_\000\000\002e\000\000\000\000\001\019\002b\000\000\002k\002L\002a\000\000\002m\000\000\000\000\000\000\000\000\002M\005\030\000\000\000\000\000\000\000\000\000\000\002b\000\000\000\000\003\003\002]\002m\002[\000\000\000\000\002_\000\000\002e\002\b\002\t\000\000\002\012\000\000\002k\000\000\002a\000\000\005\031\000\000\005 \000\000\0015\002L\002_\000\000\002e\000\000\000\000\001\028\000\000\002M\002k\004\192\002a\002m\000\000\002b\000\000\000\000\000\000\003\005\000\000\000\000\002[\000\000\000\000\002\b\002\t\005!\000\000\002\b\002\t\002m\000\000\001%\002]\001?\000\000\000\000\000\000\002L\000\000\000\000\002_\002L\003\001\002\012\000\000\002M\000\000\000\000\002k\002M\002a\000\000\005\"\002\b\002\t\003\t\000\000\000\000\002[\003\017\000\000\005#\002[\005$\000\000\000\000\000\000\002L\002b\002m\000\000\000\000\000\000\002]\000\000\002M\000\000\000\000\000\000\005^\000\000\000\000\000\000\000\000\002\012\003\023\000\000\000\000\002[\000\000\000\000\000\000\000\000\000\000\000\000\002_\000\000\003\001\000\000\002\b\002\t\000\000\005&\002k\000\000\002a\000\000\005(\0052\002b\000\000\002]\000\000\002L\000\000\002]\000\000\005\\\000\000\000\000\000\000\002M\002\012\000\000\002m\000\000\002\012\001\014\000\000\000\000\001\015\003\029\005]\000\000\002[\000\000\002_\000\000\003\001\000\000\001[\002]\000\000\000\000\002k\000\000\002a\002b\000\000\000\000\000\000\002b\002\012\000\000\001\017\000\000\005\152\002\b\002\t\001\\\002\179\000\000\001^\001_\000\000\002m\000\000\000\000\000\000\000\000\000\000\002L\000\000\000\000\002_\000\000\003\001\002b\002_\002M\003\001\000\000\002k\000\000\002a\003%\002k\002]\002a\000\000\000\000\001!\002[\000\000\000\000\000\000\002\b\002\t\002\012\000\000\000\000\000\000\000\000\002m\002_\000\000\003\001\002m\002\b\002\t\002L\000\000\002k\000\000\002a\000\000\000\000\000\000\002M\000\000\001\019\000\000\002L\002b\003*\000\000\000\000\001c\000\000\000\000\002M\002[\000\000\002m\000\000\000\000\000\000\000\000\001d\000\000\0036\002\b\002\t\002[\000\000\002]\000\000\000\000\000\000\000\000\002_\000\000\003!\002\b\002\t\002L\002\012\000\000\002k\000\000\002a\000\000\000\000\002M\0015\002\180\000\000\002L\000\000\000\000\000\000\001\028\000\000\003;\000\000\002M\002[\000\000\000\000\002m\000\000\002b\000\000\000\000\002]\003@\000\000\000\000\002[\000\000\001w\002\b\002\t\000\000\000\000\002\012\002]\001%\001\146\001\196\001b\000\000\000\000\000\000\000\000\002L\000\000\002\012\002_\000\000\002e\002\b\002\t\002M\000\000\000\000\002k\000\000\002a\000\000\002b\000\000\000\000\003O\000\000\002L\002[\000\000\000\000\002]\000\000\000\000\002b\002M\000\000\000\000\000\000\002m\000\000\000\000\002\012\002]\000\000\003R\000\000\000\000\002[\002_\000\000\002e\002\b\002\t\002\012\000\000\000\000\002k\000\000\002a\000\000\002_\000\000\003\001\000\000\000\000\002L\002b\000\000\002k\000\000\002a\000\000\000\000\002M\000\000\000\000\000\000\002m\002b\003X\002]\000\000\002\b\002\t\000\000\000\000\002[\000\000\000\000\002m\000\000\002\012\000\000\002_\000\000\003\001\002L\000\000\002\b\002\t\002]\002k\000\000\002a\002M\002_\000\000\003\001\000\000\000\000\003Z\002\012\002L\002k\000\000\002a\002b\002[\000\000\000\000\002M\000\000\002m\000\000\000\000\000\000\003d\000\000\000\000\000\000\000\000\000\000\000\000\002[\002m\000\000\002b\000\000\000\000\002]\000\000\000\000\000\000\002_\000\000\003\001\000\000\000\000\000\000\000\000\002\012\002k\001\014\002a\000\000\001\015\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002_\000\000\003!\002\b\002\t\000\000\000\000\002]\002k\002m\002a\000\000\002b\000\000\000\000\000\000\001\017\002L\002\012\000\000\000\000\000\000\000\000\002]\0013\002M\002\b\002\t\000\000\002m\000\000\003m\000\000\000\000\002\012\000\000\000\000\000\000\002[\002_\002L\002e\000\000\002b\001[\000\000\000\000\002k\002M\002a\000\000\000\000\000\000\001!\003p\000\000\000\000\000\000\000\000\002b\000\000\002[\000\000\001\\\001l\000\000\001^\001_\002m\000\000\002_\000\000\002e\000\000\000\000\002\b\002\t\000\000\002k\000\000\002a\000\000\001\019\000\000\000\000\000\000\002_\000\000\002e\002L\000\000\002]\000\000\000\000\002k\000\000\002a\002M\000\000\002m\000\000\000\000\002\012\003~\000\000\000\000\001m\000\000\001n\002(\002[\000\000\000\000\000\000\002]\002m\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\b\002\t\002\012\0015\002b\000\000\000\000\000\000\001u\000\000\001\028\000\000\000\000\000\000\002L\000\000\000\000\000\000\000\000\001d\000\000\000\000\002M\003t\000\000\000\000\000\000\002b\003\129\000\000\000\000\002_\000\000\002e\000\000\002[\001%\000\000\001;\002k\002]\002a\000\000\000\000\000\000\000\000\002\158\000\000\000\000\000\000\000\000\002\012\000\000\000\000\002_\000\000\002e\000\000\002\b\002\t\002m\000\000\002k\000\000\002a\002\212\001l\000\000\001^\001_\000\000\001w\002L\000\000\000\000\000\000\002b\000\000\000\000\001x\002M\001b\000\000\002m\002\b\002\t\000\000\000\000\002]\000\000\003\139\000\000\000\000\002[\000\000\000\000\000\000\000\000\002L\002\012\002\b\002\t\000\000\002_\000\000\002e\002M\002\217\002\233\002\234\000\000\002k\000\000\002a\002L\000\000\003\144\002\b\002\t\002[\000\000\000\000\002M\000\000\002b\000\000\000\000\000\000\003\193\000\000\000\000\002L\002m\001u\000\000\002[\000\000\000\000\000\000\002M\000\000\002\b\002\t\000\000\001d\003\206\002]\000\000\000\000\000\000\000\000\002_\002[\002e\000\000\002L\000\000\002\012\000\000\002k\000\000\002a\000\000\002M\000\000\000\000\000\000\002\b\002\t\003\252\003\131\000\000\002]\000\000\000\000\000\000\002[\000\000\000\000\000\000\002m\002L\002b\002\012\000\000\002\b\002\t\000\000\002]\002M\000\000\000\000\000\000\000\000\001\014\004>\001w\001\015\000\000\002\012\001@\000\000\002[\000\000\001x\002]\001b\003G\002b\002_\000\000\003\001\000\000\000\000\000\000\000\000\002\012\002k\000\000\002a\001B\001\017\000\000\000\000\002b\000\000\004\203\002\158\000\000\002]\000\000\003H\000\000\000\000\000\000\002_\000\000\003\001\002m\000\000\002\012\002b\000\000\002k\000\000\002a\002\212\001l\000\000\001^\001_\002_\000\000\002e\000\000\002]\000\000\000\000\001!\002k\000\000\002a\000\000\000\000\002m\002b\002\012\000\000\002_\000\000\002e\002\b\002\t\002\011\000\000\001/\002k\000\000\002a\000\000\002m\000\000\000\000\000\000\002\012\002L\000\000\001\019\002\217\002\233\002\234\002b\002_\002M\002e\002\b\002\t\002m\000\000\005r\002k\000\000\002a\000\000\000\000\000\000\002[\000\000\000\000\002L\000\000\000\000\003J\000\000\001u\002\b\002\t\002M\002_\000\000\002e\002m\000\000\005u\000\000\001d\002k\000\000\002a\002L\002[\0015\000\000\000\000\000\000\000\000\002_\002M\001\028\002\b\002\t\000\000\005\004\005\132\002`\000\000\002a\002m\000\000\000\000\002[\004\001\000\000\002L\002\b\002\t\000\000\000\000\000\000\002]\000\000\002M\000\000\000\000\001%\000\000\001?\005\135\002L\000\000\002\012\000\000\000\000\000\000\002[\000\000\002M\001w\000\000\000\000\000\000\000\000\005\148\002]\000\000\001x\000\000\001b\000\000\002[\000\000\000\000\000\000\000\000\002\012\002b\000\000\000\000\002\b\002\t\000\000\000\000\000\000\002]\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002L\000\000\002\012\002\b\002\t\000\000\000\000\002b\002M\000\000\002_\000\000\002e\000\000\005\151\002]\000\000\002L\002k\000\000\002a\002[\000\000\000\000\000\000\002M\002\012\002b\000\000\000\000\002]\005\172\000\000\000\000\002_\000\000\002e\000\000\002[\002m\000\000\002\012\002k\000\000\002a\000\000\000\000\002\b\002\t\000\000\000\000\002b\000\000\000\000\002_\000\000\002e\000\000\000\000\000\000\000\000\002L\002k\002m\002a\000\000\002b\000\000\000\000\002M\002\b\002\t\000\000\000\000\002]\005\175\000\000\000\000\002_\000\000\002e\000\000\002[\002m\002L\002\012\002k\000\000\002a\002\158\000\000\002]\002M\002_\000\000\002e\000\000\000\000\005\179\000\000\000\000\002k\002\012\002a\000\000\002[\000\000\002m\002\212\001l\002b\001^\001_\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002m\000\000\000\000\000\000\000\000\002b\000\000\000\000\000\000\002\b\002\t\000\000\000\000\002]\000\000\002_\000\000\002e\000\000\000\000\000\000\000\000\000\000\002k\002\012\002a\000\000\000\000\002\217\002\233\002\234\002\n\002_\002\158\002e\000\000\002]\000\000\002\b\002\t\002k\000\000\002a\000\000\002m\002\b\002\t\002\012\000\000\002b\000\000\000\000\002\212\001l\001u\001^\001_\002\b\002\t\002L\002G\002m\000\000\000\000\000\000\001d\000\000\002M\000\000\000\000\000\000\002L\002b\006\186\000\000\000\000\002_\000\000\002e\002M\002[\000\000\000\000\000\000\002k\006\188\002a\000\000\000\000\000\000\000\000\005\190\002[\000\000\002\217\002\233\002\234\002\011\000\000\002_\000\000\002e\000\000\000\000\000\000\002m\000\000\002k\002\012\002a\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001w\000\000\000\000\001u\006\016\000\000\000\000\000\000\001x\002\011\001b\002m\000\000\000\000\001d\000\000\002]\000\000\006\232\000\000\002\012\006\233\000\000\000\000\006\019\000\000\000\000\002\012\002]\000\000\006\016\000\000\000\000\006\020\000\000\000\000\000\000\000\000\001[\002\012\005\224\000\000\000\000\002_\006\232\000\000\000\000\006\233\000\000\000\000\006\019\002`\002b\002a\000\000\000\000\000\000\001\\\001l\006\020\001^\001_\006\021\000\000\002b\000\000\001w\000\000\000\000\000\000\000\000\000\000\002_\000\000\001x\000\000\001b\000\000\000\000\002_\002`\002e\002a\000\000\000\000\000\000\000\000\002k\006\021\002a\006\022\002_\006\016\002e\000\000\000\000\000\000\000\000\006\023\002k\001m\002a\001n\006\206\006\208\000\000\006\232\000\000\002m\006\233\000\000\006\235\006\019\000\000\006\016\000\000\006\022\000\000\000\000\000\000\002m\006\020\000\000\000\000\006\023\001u\000\000\000\000\006\232\000\000\006\025\006\233\000\000\000\000\006\019\000\000\001d\006\234\000\000\006\026\000\000\001[\000\000\006\020\006\028\000\000\000\000\000\000\000\000\000\000\006\021\000\000\000\000\000\000\006\030\000\000\006\025\002\b\002\t\000\000\001\\\001l\000\000\001^\001_\006\026\000\000\000\000\000\000\006\031\006\028\002L\006\021\000\000\000\000\000\000\000\000\000\000\006\022\002M\006\030\000\000\000\000\000\000\000\000\000\000\006\023\000\000\001w\000\000\002\b\002\t\002[\000\000\000\000\006\031\001x\000\000\001b\006\238\006\022\000\000\000\000\001m\002L\001n\0065\000\000\006\023\000\000\000\000\001\014\002M\000\000\001\015\000\000\000\000\001@\006\025\000\000\000\000\006\243\000\000\000\000\000\000\002[\000\000\006\026\001u\000\000\000\000\000\000\006\028\000\000\000\000\000\000\000\000\001B\001\017\001d\006\025\001\014\006\030\000\000\001\015\002]\000\000\001)\000\000\006\026\000\000\000\000\000\000\000\000\006\028\000\000\002\012\006\031\000\000\000\000\000\000\000\000\000\000\000\000\006\030\001[\000\000\001.\001\017\000\000\000\000\000\000\000\000\000\000\001[\001!\000\000\000\000\002]\006\031\000\000\002b\000\000\000\000\001\\\001l\000\000\001^\001_\002\012\000\000\001w\001/\001\\\001l\000\000\001^\001_\000\000\001x\000\000\001b\000\000\000\000\001\019\001!\000\000\000\000\002_\000\000\004\012\000\000\000\000\000\000\002b\000\000\002k\000\000\002a\000\000\000\000\000\000\001/\000\000\000\000\000\000\000\000\001m\000\000\001n\001\147\000\000\000\000\000\000\001\019\000\000\001m\002m\001n\001}\000\000\002_\000\000\004\b\000\000\000\000\000\000\000\000\0015\002k\000\000\002a\001u\000\000\001[\001\028\000\000\000\000\000\000\001=\000\000\001u\000\000\001d\000\000\000\000\000\000\000\000\000\000\000\000\002m\001[\001d\001\\\001l\000\000\001^\001_\0015\000\000\001[\001%\000\000\001?\000\000\001\028\001[\000\000\000\000\001=\001\\\001l\000\000\001^\001_\000\000\000\000\000\000\000\000\001\\\001l\000\000\001^\001_\000\000\001\\\001l\000\000\001^\001_\000\000\001%\000\000\001?\000\000\001w\001m\000\000\001n\001z\000\000\000\000\000\000\001x\001w\001b\000\000\000\000\000\000\000\000\000\000\000\000\001x\001m\001b\001n\001p\001[\000\000\000\000\000\000\001u\001m\000\000\001n\001s\000\000\000\000\001m\000\000\001n\001v\001d\000\000\000\000\000\000\001\\\001l\001u\001^\001_\000\000\000\000\001[\000\000\000\000\000\000\001u\000\000\001d\000\000\000\000\000\000\001u\000\000\000\000\000\000\000\000\001d\000\000\000\000\000\000\001\\\001l\001d\001^\001_\001[\000\000\000\000\000\000\002\b\002\t\000\000\000\000\000\000\000\000\000\000\000\000\001m\000\000\001n\001y\000\000\001w\002L\001\\\001l\000\000\001^\001_\000\000\001x\002M\001b\000\000\000\000\000\000\000\000\002\b\002\t\001w\000\000\000\000\001u\001m\002[\001n\001\130\001x\001w\001b\000\000\002L\000\000\001d\001w\001[\001x\000\000\001b\002M\000\000\000\000\001x\000\000\001b\000\000\000\000\001m\001u\001n\001\133\000\000\002[\000\000\001\\\001l\000\000\001^\001_\001d\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\b\002\t\005\030\000\000\000\000\001u\000\000\000\000\000\000\000\000\002]\000\000\000\000\000\000\002L\000\000\001d\000\000\001w\000\000\000\000\002\012\002M\000\000\000\000\000\000\001x\000\000\001b\005\031\001m\005 \001n\002B\000\000\002[\000\000\000\000\002]\000\000\000\000\000\000\000\000\000\000\001w\000\000\002b\002\b\002\t\002\012\002\b\002\t\001x\000\000\001b\001u\000\000\000\000\000\000\000\000\005!\002L\000\000\000\000\002L\000\000\001d\000\000\001w\002M\002\b\002\t\002M\002_\002b\003\177\001x\000\000\001b\000\000\000\000\002k\002[\002a\002L\002[\000\000\005\"\002]\000\000\002\b\002\t\002M\000\000\002\b\002\t\005#\000\000\005$\002\012\000\000\002_\002m\003K\002L\002[\000\000\000\000\002L\002k\000\000\002a\002M\000\000\005%\000\000\002M\000\000\001w\000\000\000\000\000\000\000\000\000\000\002b\002[\001x\000\000\001b\002[\002m\000\000\000\000\000\000\000\000\002]\000\000\005&\002]\000\000\002\b\002\t\005(\0052\000\000\000\000\002\012\000\000\000\000\002\012\000\000\002_\005\\\002\242\002L\000\000\000\000\000\000\002]\002k\000\000\002a\002M\000\000\000\000\000\000\000\000\005]\000\000\002\012\000\000\002b\000\000\000\000\002b\002[\000\000\000\000\002]\000\000\002m\000\000\002]\000\000\000\000\002\b\002\t\000\000\000\000\002\012\002\b\002\t\000\000\002\012\002b\000\000\000\000\000\000\002_\002L\002g\002_\000\000\002i\002L\000\000\002k\002M\002a\002k\000\000\002a\002M\000\000\002b\000\000\000\000\000\000\002b\000\000\002[\002_\000\000\002n\000\000\002[\000\000\002m\002]\002k\002m\002a\000\000\000\000\002\b\002\t\000\000\000\000\000\000\002\012\000\000\002_\000\000\002u\000\000\002_\000\000\002w\002L\002k\002m\002a\000\000\002k\000\000\002a\002M\002\b\002\t\000\000\000\000\000\000\000\000\000\000\002b\000\000\000\000\000\000\000\000\002[\002m\002L\000\000\002]\002m\000\000\000\000\000\000\002]\002M\002\b\002\t\000\000\000\000\002\012\000\000\000\000\000\000\000\000\002\012\000\000\002_\002[\002y\002L\000\000\000\000\000\000\000\000\002k\000\000\002a\002M\000\000\002\b\002\t\000\000\000\000\000\000\002b\000\000\000\000\000\000\000\000\002b\002[\000\000\000\000\002L\000\000\002m\000\000\002]\000\000\000\000\000\000\002M\000\000\000\000\000\000\000\000\000\000\000\000\002\012\000\000\000\000\002_\000\000\002{\002[\000\000\002_\000\000\002}\002k\002]\002a\002\b\002\t\002k\000\000\002a\000\000\000\000\000\000\000\000\002\012\000\000\002b\000\000\000\000\002L\002\b\002\t\000\000\002m\000\000\000\000\002]\002M\002m\000\000\000\000\000\000\000\000\000\000\002L\000\000\000\000\002\012\000\000\002b\002[\000\000\002M\002_\000\000\002\127\000\000\000\000\000\000\000\000\002]\002k\000\000\002a\000\000\002[\000\000\000\000\000\000\000\000\000\000\002\012\002b\002\b\002\t\000\000\002_\000\000\002\129\000\000\000\000\000\000\002m\000\000\002k\000\000\002a\002L\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002M\002b\002\b\002\t\002_\000\000\002\131\000\000\002]\000\000\002m\000\000\002k\002[\002a\000\000\002L\002\b\002\t\002\012\000\000\000\000\000\000\002]\002M\006\016\002\b\002\t\002_\000\000\002\133\002L\000\000\002m\002\012\000\000\002k\002[\002a\002M\002L\000\000\006\017\000\000\002b\006\019\000\000\000\000\002M\000\000\002\b\002\t\002[\000\000\006\020\000\000\000\000\002m\000\000\002b\000\000\002[\000\000\000\000\002L\000\000\002]\000\000\000\000\000\000\000\000\002_\002M\002\135\000\000\000\000\000\000\002\012\000\000\002k\000\000\002a\000\000\006\021\000\000\002[\002_\000\000\002\137\000\000\002]\000\000\000\000\000\000\002k\000\000\002a\000\000\000\000\000\000\002m\002\012\002b\000\000\000\000\002]\000\000\000\000\002\b\002\t\000\000\006\022\000\000\000\000\002]\002m\002\012\000\000\000\000\006\023\000\000\000\000\002L\000\000\000\000\002\012\002b\000\000\000\000\002_\002M\002\139\002\b\002\t\000\000\000\000\006\024\002k\002]\002a\000\000\002b\000\000\002[\000\000\000\000\002L\000\000\000\000\002\012\002b\006\025\000\000\002_\002M\002\141\000\000\000\000\002m\000\000\006\026\002k\000\000\002a\000\000\006\028\000\000\002[\002_\000\000\002\143\000\000\000\000\000\000\002b\006\030\002k\002_\002a\002\145\002\b\002\t\002m\000\000\000\000\002k\000\000\002a\000\000\000\000\006\031\000\000\000\000\000\000\002L\000\000\002]\002m\000\000\000\000\000\000\002_\002M\002\147\002\b\002\t\002m\002\012\000\000\002k\000\000\002a\000\000\000\000\000\000\002[\000\000\000\000\002L\000\000\002]\000\000\001[\000\000\000\000\001\014\002M\000\000\001\015\000\000\002m\002\012\002b\000\000\000\000\000\000\000\000\001\014\000\000\002[\005\005\001\\\001l\000\000\001^\001_\000\000\000\000\000\000\000\000\000\000\001[\001\017\000\000\000\000\000\000\002b\000\000\000\000\002_\000\000\002\149\004\187\000\000\001\017\000\000\000\000\002k\002]\002a\001\\\001l\000\000\001^\001_\000\000\000\000\005\149\000\000\002\012\000\000\000\000\000\000\002_\001m\002\151\001n\002\222\002m\001!\000\000\002k\002]\002a\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\007\001[\002\012\002b\002\b\002\t\000\000\000\000\001u\000\000\000\000\002m\001m\000\000\001n\002\225\000\000\001\019\002L\001d\001\\\001l\001[\001^\001_\000\000\002M\002b\000\000\005\n\002_\000\000\002\153\000\000\000\000\002\b\002\t\001u\002k\002[\002a\001\\\001l\000\000\001^\001_\000\000\000\000\001d\000\000\000\000\000\000\000\000\000\000\002_\000\000\002\155\002I\000\000\002m\000\000\0015\002k\001m\002a\001n\002\228\000\000\001\028\000\000\000\000\001w\004\192\000\000\000\000\000\000\002\b\002\t\000\000\001x\005\r\001b\000\000\002m\001m\000\000\001n\002\236\001u\000\000\002L\004\213\002]\005\018\001%\005\015\001?\000\000\002M\001d\001w\000\000\000\000\002\012\002\b\002\t\001%\000\000\001x\001u\001b\002[\000\000\000\000\000\000\000\000\000\000\000\000\002L\000\000\001d\002\b\002\t\002\011\000\000\000\000\002M\000\000\002b\000\000\000\000\000\000\000\000\000\000\002\012\002L\000\000\000\000\000\000\002[\000\000\000\000\000\000\002M\002\b\002\t\000\000\000\000\000\000\000\000\000\000\001w\000\000\000\000\000\000\002_\002[\002\248\002L\001x\000\000\001b\000\000\002k\002]\002a\002M\000\000\000\000\000\000\000\000\000\000\001w\000\000\000\000\002\012\002\b\002\t\000\000\002[\001x\000\000\001b\000\000\002m\000\000\002_\000\000\002\b\002\t\002L\000\000\002]\000\000\002`\000\000\002a\000\000\002M\000\000\002b\000\000\002L\002\012\000\000\000\000\000\000\000\000\000\000\002]\002M\002[\000\000\000\000\000\000\001\014\002\b\002\t\005\005\000\000\002\012\000\000\000\000\002[\000\000\000\000\000\000\002_\002b\003\021\002L\000\000\002]\000\000\000\000\002k\000\000\002a\002M\000\000\000\000\000\000\001\017\002\012\000\000\002b\000\000\000\000\000\000\000\000\000\000\002[\000\000\000\000\000\000\002_\002m\003\027\000\000\000\000\000\000\000\000\000\000\002k\002]\002a\000\000\000\000\002b\000\000\000\000\000\000\002_\000\000\003 \002\012\002]\000\000\000\000\005\007\002k\000\000\002a\000\000\002m\002\b\002\t\002\012\002\b\002\t\000\000\000\000\000\000\000\000\000\000\002_\000\000\003(\000\000\002L\002b\002m\002L\002k\002]\002a\000\000\002M\005\n\000\000\002M\000\000\002b\000\000\000\000\002\012\002\b\002\t\000\000\000\000\002[\000\000\000\000\002[\002m\000\000\000\000\002_\000\000\003-\002L\002\b\002\t\000\000\000\000\002k\000\000\002a\002M\002_\002b\003/\000\000\000\000\000\000\002L\000\000\002k\000\000\002a\000\000\002[\000\000\002M\000\000\000\000\002m\002\b\002\t\005\r\000\000\000\000\000\000\000\000\002\b\002\t\002[\002_\002m\0032\004\213\002L\005\017\002]\005\015\002k\002]\002a\002L\002M\000\000\000\000\000\000\000\000\002\012\001%\002M\002\012\002\b\002\t\000\000\000\000\002[\000\000\000\000\000\000\002m\000\000\000\000\002[\000\000\000\000\000\000\000\000\002]\000\000\001[\000\000\000\000\002b\002S\000\000\002b\000\000\000\000\002\012\000\000\000\000\000\000\002]\000\000\000\000\000\000\000\000\000\000\001\\\002\179\000\000\001^\001_\002\012\000\000\000\000\006\016\000\000\000\000\002_\000\000\0039\002_\002b\003>\000\000\000\000\002k\002]\002a\002k\000\000\002a\006\223\000\000\002]\006\019\000\000\002b\002\012\000\000\000\000\000\000\000\000\000\000\006\020\002\012\000\000\002m\006\016\002_\002m\003C\000\000\000\000\000\000\000\000\000\000\002k\002\011\002a\001[\000\000\000\000\002b\002_\006\017\003F\000\000\006\019\002\012\002b\000\000\002k\006\021\002a\001c\000\000\006\020\002m\001\\\001l\000\000\001^\001_\000\000\000\000\001d\000\000\000\000\000\000\002_\006\016\003x\002m\000\000\000\000\000\000\002_\002k\003z\002a\006\022\000\000\000\000\000\000\002k\006\021\002a\006\017\006\023\000\000\006\019\000\000\003e\000\000\000\000\000\000\001[\000\000\002m\006\020\002_\001m\006\224\001n\004<\002m\000\000\000\000\002`\000\000\002a\003g\000\000\006\022\000\000\001\\\002\179\001w\001^\001_\006\025\006\023\000\000\000\000\000\000\001\146\001u\001b\006\021\006\026\000\000\000\000\001[\000\000\006\028\000\000\000\000\001d\006#\000\000\000\000\000\000\000\000\000\000\006\030\000\000\001[\000\000\000\000\000\000\000\000\001\\\002\179\006\025\001^\001_\006\022\000\000\000\000\006\031\000\000\000\000\006\026\000\000\006\023\001\\\002\179\006\028\001^\001_\000\000\000\000\000\000\000\000\000\000\001\014\000\000\006\030\001\015\000\000\000\000\006,\000\000\001c\000\000\000\000\000\000\000\000\000\000\001w\000\000\000\000\006\031\000\000\001d\001\014\006\025\001x\001\015\001b\000\000\000\000\001\017\000\000\000\000\006\026\000\000\000\000\000\000\000\000\006\028\000\000\004\187\000\000\000\000\000\000\000\000\000\000\000\000\001c\006\030\003e\001\017\000\000\000\000\000\000\000\000\005\163\000\000\001[\001d\000\000\004\187\001c\000\000\006\031\000\000\000\000\000\000\001!\003f\000\000\000\000\001[\001d\005\176\001w\005\173\001\\\002\179\001[\001^\001_\000\000\001\146\000\000\001b\003e\001\014\001!\000\000\001\015\001\\\002\179\000\000\001^\001_\000\000\001\019\001\\\002\179\006\003\001^\001_\000\000\000\000\003j\000\000\000\000\001[\000\000\000\000\001w\000\000\000\000\001\017\000\000\000\000\001\019\000\000\001\146\000\000\001b\000\000\000\000\003\226\001w\000\000\001\\\002\179\000\000\001^\001_\000\000\001\146\000\000\001b\000\000\000\000\006x\000\000\000\000\0015\000\000\000\000\000\000\001c\006\005\000\000\001\028\000\000\000\000\001!\004\192\000\000\000\000\000\000\001d\000\000\000\000\001c\000\000\0015\000\000\000\000\000\000\001[\001c\000\000\001\028\000\000\001d\000\000\004\192\000\000\001%\000\000\001?\001d\000\000\000\000\001\019\000\000\000\000\002\180\001\\\002\179\000\000\001^\001_\000\000\000\000\001[\000\000\000\000\001%\001c\001?\005\203\000\000\002\b\002\t\000\000\000\000\000\000\005\203\000\000\001d\000\000\001w\001\014\001\\\002\179\001\015\001^\001_\000\000\001\146\001\014\001b\000\000\001\015\003\152\001w\000\000\0015\000\000\000\000\000\000\003\161\001w\001\146\001\028\001b\006\003\000\000\000\000\001\017\001\146\000\000\001b\001\014\000\000\005\216\001\015\001\017\000\000\003\226\000\000\000\000\005\215\000\000\003\162\001c\000\000\000\000\000\000\000\000\001%\001w\003\233\003\229\000\000\000\000\001d\002\b\002\t\001\146\001\017\001b\000\000\000\000\000\000\004\203\001!\001\014\000\000\000\000\001\015\001c\006\004\001\014\001!\000\000\001\015\000\000\000\000\002^\002\011\000\000\001d\006\003\000\000\001\014\001\014\000\000\001\015\001\015\000\000\003\165\000\000\000\000\001\017\001\019\000\000\001!\000\000\005\198\001\017\000\000\001[\001\019\000\000\000\000\000\000\000\000\001w\003i\000\000\000\000\001\017\001\017\000\000\000\000\001\146\000\000\001b\000\000\003\155\001\\\001]\000\000\001^\001_\001\019\000\000\000\000\006\012\000\000\001!\001\014\000\000\001w\001\015\000\000\001!\001\014\0015\000\000\001\015\001\146\002_\001b\002\011\001\028\0015\000\000\001!\001!\002`\000\000\002a\001\028\000\000\002\012\000\000\004\224\001\017\001\019\004\227\000\000\000\000\000\000\001\017\001\019\000\000\001\014\000\000\0015\001\015\001%\000\000\003\233\000\000\000\000\001\028\001\019\001\019\001%\004\211\001?\000\000\000\000\001\014\000\000\000\000\001\015\001c\000\000\000\000\000\000\000\000\000\000\001\017\001!\000\000\000\000\000\000\001d\000\000\001!\001%\0015\001?\000\000\000\000\002_\000\000\0015\001\028\001\017\000\000\000\000\004\211\002`\001\028\002a\000\000\000\000\004\224\0015\0015\005\244\001\019\000\000\000\000\000\000\001\028\001\028\001\019\001!\006\181\001O\000\000\000\000\001%\000\000\001?\000\000\000\000\000\000\001%\000\000\001?\000\000\000\000\000\000\001!\001\014\000\000\001w\001\015\000\000\001%\001%\001?\001?\000\000\001\146\001\019\001b\001\014\000\000\001[\001\015\000\000\001\014\0015\000\000\001\015\000\000\000\000\000\000\0015\001\028\001\017\001\019\000\000\001\163\000\000\001\028\000\000\001\\\002\164\001\201\001^\001_\000\000\001\017\000\000\000\000\000\000\000\000\001\017\000\000\000\000\000\000\000\000\000\000\000\000\001%\000\000\001?\0015\000\000\000\000\001%\000\000\001?\000\000\001\028\000\000\001!\001\014\001\203\000\000\001\015\000\000\001\014\001\014\0015\001\015\001\015\000\000\000\000\001!\000\000\001\028\000\000\000\000\001!\002\031\000\000\000\000\000\000\000\000\001%\000\000\001?\000\000\001\017\001\019\000\000\000\000\000\000\001\017\001\017\000\000\000\000\000\000\001c\000\000\000\000\001%\001\019\001?\000\000\000\000\000\000\001\019\001\014\001d\000\000\001\015\000\000\000\000\001\014\000\000\000\000\001\015\000\000\000\000\000\000\000\000\000\000\001\014\000\000\001!\001\015\000\000\000\000\001\014\001!\001!\001\015\0015\000\000\001\017\000\000\000\000\000\000\000\000\001\028\001\017\000\000\000\000\0022\000\000\0015\000\000\000\000\000\000\001\017\0015\000\000\001\028\001\019\000\000\001\017\002\169\001\028\001\019\001\019\001w\002\174\000\000\001\014\000\000\001%\005\005\001?\001\146\001\014\001b\001!\001\015\000\000\000\000\000\000\000\000\001!\001%\000\000\001?\000\000\000\000\001%\000\000\001?\001!\000\000\000\000\000\000\001\017\000\000\001!\000\000\000\000\000\000\001\017\0015\000\000\000\000\001\019\000\000\0015\0015\001\028\000\000\001\019\000\000\002\191\001\028\001\028\000\000\000\000\002\198\002\205\001\019\001\014\000\000\000\000\001\015\000\000\001\019\001\014\000\000\000\000\001\015\000\000\005\007\000\000\000\000\001%\001\014\001?\001!\001\015\001%\001%\001?\001?\000\000\000\000\000\000\000\000\001\017\0015\000\000\000\000\000\000\000\000\001\017\0015\001\028\000\000\000\000\000\000\002\214\005\n\001\028\001\017\0015\000\000\004K\001\019\000\000\001\014\0015\001\028\005\005\000\000\000\000\004\164\000\000\001\028\000\000\000\000\000\000\004\176\001%\001\014\001?\001!\005\005\000\000\001%\000\000\001?\001!\000\000\000\000\000\000\000\000\001\017\001%\000\000\001?\001!\000\000\000\000\001%\000\000\001?\000\000\000\000\000\000\000\000\001\017\0015\005\r\000\000\001\019\000\000\000\000\000\000\001\028\000\000\001\019\001\014\004\189\004\213\001\015\005\016\000\000\005\015\000\000\001\019\000\000\002\b\002\t\005\007\000\000\000\000\001\014\000\000\001%\001\015\000\000\000\000\000\000\000\000\001%\000\000\001?\005\007\001\017\000\000\000\000\000\000\000\000\002l\000\000\000\000\002\b\002\t\0015\000\000\000\000\000\000\005\n\001\017\0015\001\028\000\000\001\014\000\000\004\210\005\005\001\028\000\000\0015\000\000\004\226\005\n\000\000\003G\000\000\001\028\000\000\000\000\001\014\005\128\001!\005\005\000\000\000\000\000\000\000\000\001%\000\000\001?\001\017\001\014\000\000\001%\001\015\001?\001!\000\000\005\209\000\000\000\000\000\000\001%\000\000\001?\000\000\001\017\002\b\002\t\005\r\001\019\000\000\000\000\000\000\000\000\002\011\000\000\000\000\001\017\000\000\004\213\000\000\005\014\005\r\005\015\001\019\002\012\005\007\000\000\003\014\000\000\000\000\000\000\000\000\004\213\001%\005\026\000\000\005\015\000\000\002\011\000\000\000\000\005\007\001\014\000\000\000\000\001\015\000\000\001%\001\014\002\012\000\000\001\015\0015\001!\005\n\000\000\000\000\000\000\000\000\001\028\000\000\001\014\000\000\005\146\001\015\001\014\000\000\0015\001\015\001\017\005\n\000\000\000\000\000\000\001\028\001\017\002_\003J\005\170\000\000\000\000\000\000\001\019\000\000\002`\001%\002a\001?\001\017\000\000\000\000\000\000\001\017\002\011\000\000\000\000\000\000\000\000\000\000\000\000\001%\002_\001?\000\000\002\012\005\r\001!\000\000\000\000\002`\000\000\002a\001!\000\000\000\000\000\000\004\213\000\000\005\230\000\000\005\015\005\r\000\000\000\000\000\000\001!\0015\000\000\000\000\001!\000\000\001%\004\213\001\028\006\000\001\019\005\015\0068\000\000\000\000\000\000\001\019\000\000\000\000\000\000\000\000\000\000\001%\000\000\000\000\000\000\000\000\000\000\000\000\001\019\000\000\002_\000\000\001\019\001%\000\000\001?\000\000\000\000\002`\000\000\002a\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0015\000\000\000\000\000\000\000\000\000\000\0015\001\028\000\000\000\000\000\000\006\141\000\000\001\028\000\000\000\000\000\000\006\145\000\000\0015\000\000\000\000\000\000\0015\000\000\000\000\001\028\000\000\000\000\000\000\001\028\000\000\000\000\001%\000\000\001?\000\000\000\000\000\000\001%\000\000\001?\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001%\000\000\001\198\000\000\001%\000\000\003\228"))
+ ((16, "\000%\000\193\000G\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\012\000\000\000\000\000\129\001\152\000\030\0003\000#\000\004\000\190\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000b\000\000\000\000\000\000\000\000\000\000\000t\000\000\000\000\000\000\000\242\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000=2\000\000\000\000\000\000\000\254\000\000\000\000\000\000\000\000\000\000\000\000\000\000'\238\001T\001>\000\223\000\000\001B9\220\001\236\001\218\000:\000\000\001x\000\000\000\182\003\156\000\000\002\150\000\000\000\000\000\000\000\000\000\000\001\022\000\000\000\218\003\202\bf\000\000\000\000\011\018'\238\000\000\000\000\001\254\000\000\000\027\000\000:~\002\184\000\000\001\156\001r\000\000\000\000\002\172\002\142\002\208\003b\001\226\003\202\004\142\000f\001\194\0022\003\216\002\152\011b\000\000\005(\003\244\003\188\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004r\000\000\t>\005(\011\194\000\000\000\000\004.\005d\004\0301\236\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\148\000\000\004\168\005l\005@\000\000\000\000\000\000\000\000\000\173\000\000\000\000\005\144\000\167\006\018\006(\007\214\000\000\0050\005H\006*\000Q\004\228\006L \232\000\000\000\000\005X\006\254\011\204\000\000!\b\001\244!\026\"V\000\000\003B\000\000\000\000\000\000\000\000\006\018=F\006\020\000\000\001\012\0064\000\000\004P6\150\000\131\000\000\001\172\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0002:\005\190\000\000\000\000\000\000\000\192\000\000\tD\000\000\000\000\002\164\000o\000\000\000\000\003\248\000\000\006n\000\000\002\164\t\148\002\164\000\000\000\000\000\000\000\000\000\0007 \000\000\007\"\006@\000\000=\168\007N\030`\000\000\000\000\000\000\0062\000\000\000\000\000\000\000\000\006F\000\000\000\000\000\000\000\000\000\0002L\000\000\000\000\000\000\000\000\000\000\000\000\001\158\007N\000\000\000\000\000\000\006F\007\1342\146\006\224\007p\015\214\000\000\003\014\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000(\000\000\000\000\000\000\000\000\b\0122\160\000\000\000\000\007\030\b\0042\214\000\000\000\000\000\00038\007\0143\152\000\000\007\014\000\0003\164\007\014\000\0003\228\007\014\000\000\007\014\000\000\000\000\007\014\000\000\000\0004J\000\000\007\0144\138\000\000\007\014\002|\000\000\000\000\"V\000\000\000\000\000\000\000\000\007\014\"z\000\000\000\000\000\000\007\014\000\000\006F\007\246\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\016\000\000\007\136\000\000=\132\006F\000\000\000\000\000\000\000\000\b\b\b\184\012$\b\026\b\030\b@\b\028\005\014\b`\0001\t\006\000\000\000\000\000\029\005\136\b\160\001\172\b\200\bL\000\000\000\145\004\138\005\180\007\136\n\"\000\000\000\000C\158\000\000C\224\t\212\000\000=\198\006F>@\006F\000\000\003\"\000\000\003x\000\000\000\000\003\220\000\000\000\000\000\000\nt\000\000\n\030\000\145\000\000\000\000\t>\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\145\000\000\000\000\000\145\000\000\b\200\007\014\000\000\002\182\004\228\000\000\002\182\000\000\000\000\n\206\000\145\000\000\000\000\000\000\000\000\000\000\000\000\002\182\012\132\rL\n4\t\218\"\152\000n\000\000\t\130\b\182\r\158\t\234\b\228\025X1N\000\000\000\000\000\000\000\000\000\000\0032\t\188\000\000\000\000\000\000\t\250\b\244\007V\002\182\011\240\000\000\000\145\000\000\000\000\000\000\001\244\000\000>T\006F\r\166\n\018\t\030\r\254\n \t0\014\180\"\186\007\014\015\024\n\"\t89\190\n\244\000\000#\002\007\014>x\006F\n\238\000\000\000\000\000\000\000\000\007\148\011&\011L\000\000\000\000\b\176\015 \n\208\t>4\172\007\014\015t\n\222\tF6(\000\000>\172\000\000\000\000\015|\"\244\018\\\000\000\000\000\000\000\000\000>\208\000\000\000\000\000\000\007\172\016B\000\000\000\000\000\000\000\000#^>\222\000\000\000\000\000\000\000\000\000\000\n\170\016\150\000\000\n\180$\"\n\180$,\n\180\000\000?\026\000\000$\128\n\180\016\234\004\152\016\244\000\000\000\000$\136\n\180%\022\n\180%\030\n\180%\250\n\180&\002\n\180&\026\n\180&\152\n\180&\246\n\180&\254\n\180'\140\n\180'\148\n\180'\232\n\180(v\n\180(\128\n\180)\014\n\180)^\n\180)h\n\180)\246\n\180*F\n\180*\212\n\180\t\170*\2484\232\007\148\011x\000\000+8;l\000\000\017N\000\000?,\000\000\006F;\166\000\000\006F?P\006F\000\000\017\184\000\000\000\000\000\000+\\\000\000\000\000\000\000\000\000\000\000\007\014\000\000\000\000?\210\000\000\006F\000\000\000\000;\166\011\136\000\000@6\006F\018\018\000\000\000\000\011\"\000\000@H\006F\018\160\000\000\000\000\018\196\000\000\000\000\000\000@Z\006F\019\028\000\000\n\252\019\132\000\0005J\000\000\007\0145\142\000\000\007\0145\176\000\000\007\014\003d\000\000\000\000\000\000\000\000\000\0005\240\007\014\004\222\005\022\000\000\000\000\000\000\n\180\019\222\000\000\000\000\000\000+\150\n\180\000\000\000\000\000\000\000\000\0206\000\000\000\000\000\000\n\180\020D\000\000\020\158\000\000\000\000\000\000\021\004\000\000\000\000\000\000\000\000@\146\000\000\000\000\021^\000\000\000\000\000\000,H\n\180\021l\000\000\000\000\000\000,\138\n\180\021\196\000\000\000\000,\176\n\180\n\180\000\000\007\228\022\030\000\000\000\000-\b\n\180\022l\000\000\000\000-(\n\180-v\n\180\000\000.\004\n\180\000\000\000\000\022\250\000\000\000\000.\152\n\180\023,\000\000\000\000.\200\n\180\023\\\000\000\000\000.\232\n\180\000\000/\000\n\180\000\000;\138\000\000\000\000\n\180\000\000\000\000\023\142\000\000\000\000\023\192\000\000\000\000\011D\000\000\000\000\024\028\000\000\024$\000\000\000\000\000\000\007\148\011\226\000\0007\022\n<\002\164\025\004\000\0007r\000\000\000\000\000\0007\194\000\000\000\000\025$\000\000\025\146\000\000\000\000\000\000\000\000/\n\000\000\000\000\000\000/f\n\1800r\n\180\000\000\n\252\025\156\000\000\000\000\025\236\000\0000T\000\000\000\0001N\000\000\000\000\000\000\026\134\000\000\000\000\000\000\000\000\026\144\000\000\000\000\000\000\000\000\012\152\000\000\000\000\000\000\003\154\000\000\000<\000\000\000;\000\000\0128\000\000\004\144\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\180\000\000\012\164\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\184\007\232\002\182\027T\000\000\011\166\t\224\012*\001\144\t\136\002\182\r@\000\145\t\176\002\182\000\000\027x\000\000\004\142\000\000\011\194\t\238\004X\000\000\000\000\000\000\000\000\000\000\011\218\001.\000\146\000\000\000\000\000\000;\222\000\000C\240\000\000\t\246\000\000\n\016\000\000\000\000\000\000\000\000\002\158\000\000\000\000\000\000\011*\002\164\000\000\002\164\001\178\000\000\rv\002\164\002\164\n\024\000\000\027\186\000\000\000\000\n8\012\172\000\0000\180\005$\000\000\000\000\000\000\000\000\000\000\000\000\n\180\000\000\028\180\000\000\n\180\000\000\000\000\014\242\000\000\000\145\000\000\016H\000\000\000\145\000\000\017\012\000\145\000\000\003Z\000\000\n<\n\022\005`\000\000\011\226\011\234\nV\012\024\012\164\017T\000\145\006\012\000\000\nZ\012\134\012\188\005\024\006\184\012\150\n\130\r\014\006\146\b\132\012\228\000\000\000\000\007\188\b\148\000\000\004\168\002\2426N\007\014\028\028\000\000\007X\003\178\012\158\n\154\011^\005\224\000\000\012\168\n\158\006\200\000\000@\172\006F\rZ\r\132\000\000\t:\000\000\012\244\n\166\006>\r2\003V\000\000\000\000\000\000\000\000\n\216\tZ\000\000\n\222\tl\000\000\bb\0164\rF\rP\n\228\006\216\t\172\000\000\n\230\007\138\n\018\000\000\rR\n\238\r\220\000\000\t\028\000\000\n\132\000\000\r\252\000\000\018\024\000\145\r\216\011\002\014\022\000\000\018\202\0056\r\236\000\000\000\000\003j\006\160\011$\000\000\019\228\000\145\011F\000\000\004\022\000\000\r\210\011\016\0212\006\154\000\000\r\222\011>\007\176\r2\r\230\r\240\011L\015F\000\000\014\000\001\200\000\000\000\000\000\000\000\000\000\171\011X\r\226@\190\006F\000\000\002\200\011\142\014\148\000\000\000\000\000\000\000\000\000\000\000\000A\000\006\164\000\000\011\182\014\246\000\000\000\000\000\000\000\000\000\000\000\000\006\174\000\000A\030\006F\011\226\000\000\006F\011\218\000\184\000\000\011\230\011\232\007\024\000\000\001\004\004L\000\000\002\190\000\000A\"\006F\006F\000\000\000\000\007\b\000\000\b\252\000\000\001\186\007\b\007\b\000\000\011\236;\204\006FA\152\006F\012\b\000\000\000\000\000\000\000\000\012\014\000\000\000\000\007N\000\000\007l\014`\011\240\015p\014*\000\000\000\000\001\196\b|\014h\000\000\000\000\011\250\015\128\014@\000\000\000\000\029\018\000\000\012\222\000\000!(6H\006F\000\000,N\018\132\000\000A\252\000\000\000\000\000\000\007\b\000\000\000\000\012:\014|\012\000\015\144\014J\000\000\000\000B\014\012\144\014\140\000\000\000\000\000\000<:\000\000\000\000\000\000\000\000\000\000\000\000\012\146\000\000\014\152\012\020\006\162\000\000\015\134\015>\012\180\014\166\000\000\000\000\014\170\012>\b*\000\000\000\000\tl6\150\005|\000\000\000\000\000\000\bL\014p\012p\000\000\014z\bL\000\000\015V\012\188\014\196\000\000\000\000\000\000\006F\003v\004(\005\180\000\000\000\000\000\000\000\000\014\138\012t\000\000\006\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006F\014z\012\128\015\208\014\138\000\0007\224\000\237\012\146\014^\003\156\000\019\012\150\015\016\000\000\015\200\028\130\000\000\000\000\029J\000\000\012\208\000\000\nL\000\000\000\000\000\000\000\000\000\000\000\000B\018\006F\000\000\015\204\029l\000\000\000\000\030\002\000\000\000\245\012\156\015r\000\000\000\0007\250:\020\015(\000\000B0\006F\0302\000\000\000\000\030T\000\000\000\000\r0\000\000\000\\\000\000\000\000\000\000\000\000\000\000\000\000:\204\000\000\000\0008\188:\208\015*\000\000BP\006F\030\234\000\000\000\000\031\028\000\000\000\000\012\184\031<\r<\000\000\012\190\012\198\002\016\002\208\012\200\t&\012\214\015|0\214\r\\\000\000\r\016\r2\tf\000\000\004*<Z\000\000\004.\000\000\rH9\0069Z\005\236\014j\006l\000\000\020\144;\138\000\000\0001\000\000\000\000\0001\000\000\000\000\0001\n\002\000\000\011\000\0001\015\1380\238\rh\000\000\0001\000\000\000\000Br\000\000\000\000\000\000\0001\000\000\000\000\r\166\000\000\r\030\005\190\r\200\000\000\rJ<\174\r\248\000\000\000\000\000\000\000\000\014\000\000\000\000\000\006\018\000\000\0001B\232\000\000\014\216\00019h\000\000\014\b\014\242\rN\016\n\014\200\000\0009r\014\014\015\002\000\000\000\000\000\000\019\012\b\026\000\000\000\000\000\000\000\000\000\000\000\000\n\170\014\020\000\000\015\018\000\000\000\000\000\000\000\000\014\026\027F\000\000\000\000\000\000\000\000\n\170\000\000\000\000\014.\031\170\000\000\000\000\000\000\000\000\000\000\002\182\000\145\000\000\000\000\007\014\000\000Bn\006F\000\000\007\212\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\202\rP\011\246\002\182\000\000\022\n\000\000\000\145\000\000\016\004\000\000\000\000\000\000\000\000\000\000 (\000\000\000\000\000\000\000\000\000\000\000\000\015\170\002\022\t\210\014p\003\144\r\148\000\000\000\226\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\138\005^\r\176\000\000\007$\016\n\015\188\014J\000\000\000\000\015\180\002\202\b\150\000\000\000\000\000\000\r\180\000\000\r\206\000\240\000\000\000\000\002\164\b\128\000\000\000\000\000\000\000\000\000\000.\226\000\000\000\000\007h\007\238\000\000\000\000C(\006F\006F\000\000CJ\006F\bP\000\000\000\000\000\000\006F\000\000\000\000\t\246\015\196\014\\\000\000\000\000\015\184\000\170\001\200\000\000\000\000\000\000\000\000\b\002\016\n\nl\015\200\014h\000\000\000\000\015\190\004\188\003\142\000\000\000\000\000\000\000\000\000\145\000\000\b\222\000\000\000\000\000\000 \004\000\000 \182\000\000\000\000\000\000\000\000\000\000-\226\000\000\000\000\000\000\005\022\000\190\000\000\000\000\000\000\000\000\000\000\002V\000\190\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0050\000\000\000\000\000\000<\198\000\000\006F\000\000\n*\000\000\000\000\000\000\001\030\000\000\000\000\000\000\001\214\000\000\000\000\000\000\0001\000\000\000\000\000\0000\250\007\014\000\000\000\000\000\014\000\000\000\000\000\000\000\000\0032\004\128\015\b\004D\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000=.\000\000\014v\000\000\000\000\000\000\000\000\005H\006\246\r@+\182\000\000\000\000\014\150/~\000\000\000\000\000\000\014\162;\020\000\000\000\000\000\000\000\000"), (16, "\006\014\003\162\002\r\002\014\001^\0007\002\244\001\191\000\189\006\177\005t\000\193\000\194\005\151\001\239\001\024\001\223\002Q\006\015\006\188\001\227\006\017\001\016\000q\001^\002R\005\153\006\242\002\014\001^\006\018\006\031\001\191\006\014\0060\002\r\002\014\001^\002`\005\203\006/\001\223\001\t\001\252\001\237\001\227\000\193\001\016\001\016\001\019\002Q\006\015\006\030\000\140\006\017\006\163\001\208\001\239\002R\006\019\001\228\005\158\001\t\006\018\006\031\001d\006\234\005\205\001\016\001\019\003\163\002`\001\t\004}\001\229\002\r\002\014\001^\001\016\001\019\003\160\005\234\005\206\004\031\006\183\001\228\001\252\005\208\000\196\000\193\000;\005\252\006\019\006\020\006\235\006\244\006\181\002b\003\158\001\229\004\212\006\021\001\253\001\223\001\191\003\167\001\235\001\227\002\017\001\016\002d\000\193\004\213\001\223\001\t\000\140\004\237\001\227\000\145\001\016\001\016\001\029\005\162\006\128\001\024\006$\006\020\001\025\003\180\002\244\002b\000@\001\020\006\245\006\021\002d\000\193\006\155\001\222\005v\006%\002\017\001!\002d\000\193\001\253\000\196\001\228\001\024\006\024\000\146\001\027\006\190\001\231\006\026\006\158\000\189\001\228\006$\000\193\000\251\000?\001\024\000\140\006\028\001\025\000\149\002e\001+\002k\002\016\001\229\001\030\006%\0007\002q\000:\001}\002g\001\024\006\029\003\171\006\024\002d\000\193\000\251\005\210\006\026\001,\001\027\003\227\002\244\003\161\000\196\001#\001J\006U\006\028\002s\006|\002e\000\196\002k\006\014\000m\002\r\002\014\001^\002q\003\243\001}\002g\000\140\006\029\000\150\001\208\001e\003\161\000\\\001\t\002Q\006\015\006\030\001\t\006\017\001\016\001\019\000`\002R\001\016\001\029\002s\001#\006\018\006\031\006\226\001\t\003\238\003\240\003\242\002e\002`\001\016\001\029\0007\001\024\0007\001\t\002f\0011\001}\002g\000\140\001\016\001\029\000\145\006{\001\t\006_\006\161\006\162\001\t\006\019\001\016\001\019\0007\006t\001\016\001\029\006V\006\227\001\162\001^\001M\001*\003\243\001\016\004\212\001\t\005P\004\001\001\030\001\189\001\024\001\016\001\029\006\130\004\160\006`\004\213\000d\001_\002\"\004\220\001a\001b\006\020\006a\000y\006\014\002b\002\r\002\014\001^\006\021\001\030\002\244\000\129\001'\000\132\001\027\002\017\0017\002d\000\193\004\212\002Q\006\015\006\030\001\030\006\017\006\206\001P\001?\002R\003\210\006\230\004\213\006$\006\018\006\031\004\214\006|\003\130\002\239\002\240\001\030\002`\006^\001\140\001^\001\012\003\246\006%\001\t\0009\001'\001\016\001\t\001A\001\016\001\029\006\024\001\t\001\016\001\019\000\128\006\026\006\019\001\016\001\019\006\231\006S\003\247\000\193\001x\001\"\006\028\001\t\000\196\002e\000\196\002k\006\159\001\016\001\029\001g\003\213\002q\000\193\001}\002g\001\t\006\029\000\140\000\135\006j\001\208\001\016\001\029\000\189\001\231\006\020\000\193\000\194\006\014\002b\002\r\002\014\001^\006\021\002s\001\030\006\160\003\133\003\138\004\212\002\017\003\249\002d\000\193\004\212\002Q\006\015\006\030\000=\006\017\000\167\004\213\001Y\002R\005\203\004\219\004\213\006$\006\018\006\031\004\245\006r\003\252\003\174\001^\000\134\002`\000\189\001z\000\179\000\193\000\194\006%\001\030\006b\006c\001{\001\250\001}\001e\000\196\006\024\005\205\006d\006e\003\227\006\026\006\019\002\237\001^\000\140\006&\000\174\001\208\006f\004\001\006\028\005\206\001\t\002e\001'\002k\005\208\006\207\001\016\001\029\005\231\002q\000\172\001}\002g\001\t\006\029\000\182\002\r\002\014\001^\001\016\001\019\000\189\000\144\006\020\000\193\000\194\006\014\002b\002\r\002\014\001^\006\021\002s\004\229\003\241\003\240\003\242\000\143\002\017\003\158\002d\000\193\002\244\002Q\006\015\006\030\003\167\006\017\000\195\000\176\005?\002R\005\203\001\t\000\165\006$\006\018\006\031\004\232\001\016\001\029\001\250\001\210\000\171\002`\000\193\006b\006c\002\244\003\168\006%\001\024\000\196\004\234\001$\006d\006e\000\196\000\189\006\024\005\205\000\193\000\251\004\208\006\026\006\019\006f\004\001\004\\\006\"\000\252\000\193\001\251\004\235\006\028\005\206\004\140\002e\001\027\002k\005\208\006\254\002\014\001^\005\224\002q\001\212\001}\002g\004 \006\029\002\016\001\016\001\024\000\255\001\024\001\025\004\\\001\025\006\020\000\193\001+\003\171\002b\002d\000\193\000\251\006\021\002s\006\014\001\216\002\r\002\014\001^\002\017\006\173\002d\000\193\005\244\005?\001\027\001,\001\027\007\001\007\002\004\206\002Q\007\004\001H\004\142\006\017\006$\005F\005G\002R\004_\001\215\001}\003\161\006\018\007\006\000\187\001\016\0007\005\247\006\160\006%\002`\005W\003\166\001\t\0007\005P\004\001\001\251\006\024\001\016\001\029\001\217\005\249\006\026\002e\004\143\001#\006\\\001#\001}\000\177\006\019\002f\006\028\001}\002g\002e\000\189\002k\000\189\000\193\000\194\000\193\000\194\002q\0011\001}\002g\005\250\006\029\006\255\006\199\002d\000\193\006\172\001\t\000\181\001\t\002\r\002\014\001^\001\016\001\029\001\016\001\029\006\020\000\196\002s\005\203\002b\000\186\001\030\006\014\006\021\002\r\002\014\001^\007\021\004\142\002\244\002\017\006@\002d\000\193\005F\005G\003\214\007\r\000\189\002Q\007\014\000\193\000\251\006\017\007\t\000\197\005\205\002R\001'\000\204\005O\001\239\006\018\007\022\005P\004\001\0017\002\244\0017\0068\002`\005\206\006%\001\030\002\244\001\030\005\208\004\211\005\198\001?\005\215\006\024\001\239\002\244\003\161\006\200\006\026\001\243\003\223\004\001\001\252\006\019\000\140\000\193\001\195\001\208\006\028\006\214\003\213\002e\001'\002k\001'\001A\002\244\001A\002\246\002q\001\254\001}\002g\001\252\006\029\002\016\000\193\0042\006\201\000\196\006\161\006\162\000\217\006\208\001\016\001\250\002\017\006\020\002d\000\193\004\\\002b\002s\000\193\000\221\006\021\002\245\001]\001^\002w\005P\004\001\002\017\004\007\002d\000\193\006\014\004?\002\r\002\014\001^\001\253\004\131\004\\\004\012\007\026\000\193\001_\002\185\003\227\001a\001b\006\209\002Q\006\015\006,\001\191\006\017\001\232\003\213\002\244\002R\001\253\004$\006%\001\223\006\018\006\031\000\205\001\227\005\238\001\016\000\218\006\024\002`\002e\006\210\003\227\006\026\001\250\004!\001\024\002\244\002f\001\025\001}\002g\006\215\006\028\001}\000\227\002e\000\234\002k\006\211\006\019\0058\003\240\003\242\002q\000\242\001}\002g\000\140\006\029\005)\001\208\001\222\001\027\001\228\006h\001R\001}\001\024\000\189\001\003\001\025\000\193\000\194\004N\001^\001f\002s\001\229\005L\003\240\003\242\004J\001\251\006\020\000\196\001\006\001g\002b\000\196\000\193\001\023\006\021\0014\006\014\001\027\002\r\002\014\001^\002\017\005\203\002d\000\193\005\251\004-\004\191\001#\000\196\002\244\007\r\000\229\002Q\007\014\002\244\000\189\006\017\006$\000\193\000\251\002R\004\194\002\186\000\235\002\244\006\018\007\017\001\157\006o\005\205\005\247\005\210\006%\002`\000\189\003\227\001\t\000\193\000\194\001#\000\238\006\024\001\016\001\029\005\206\005\249\006\026\001z\001\251\005\208\001;\000\255\0047\005\212\006\019\001\150\006\028\001}\001e\002e\004\136\002k\006\137\000\193\002\244\005\203\0007\002q\001\t\001}\002g\005\250\006\029\000\196\001\016\001\029\004\148\001]\001^\004Y\004\001\004\181\005T\003\240\003\242\000\196\001\239\001&\006\020\004k\002s\0043\002b\005\205\001\030\001\016\006\021\001_\001o\001@\001a\001b\000\196\002\017\003\213\002d\000\193\006\014\005\206\002\r\002\014\001^\001\240\005\208\002\244\001\252\007\020\005\209\000\193\0017\004\203\001'\001\239\000\193\002Q\006\015\001\030\001\t\006\017\000\243\004\196\004\221\002R\001\016\001\029\006%\001O\006\018\006(\006\169\001p\001\222\001q\002\192\006\024\002`\001@\001>\002\026\006\026\001\152\001\252\001U\001'\000\193\000\140\001A\0053\001\208\006\028\001\149\001\t\002e\004\236\002k\000m\006\019\001\016\001\029\001<\002q\001x\001}\002g\001\253\006\029\000\189\005\028\004o\000\193\000\251\004\238\001g\001m\001\016\000\193\001V\001\024\004\232\001\024\001\025\000\196\001\025\002s\003\001\001\239\004\215\000\193\000\251\001w\006\020\004<\001\024\004\234\002b\005\029\005]\005\030\006\021\000\196\001\253\001\156\001\196\001\168\001\027\002\017\001\027\002d\000\193\001]\001^\003\197\0039\004\235\001\252\000\193\000\251\000\193\001\t\0069\003\018\000\196\006+\005?\001\016\001\019\005\031\004E\001\t\001_\002\185\001z\001a\001b\001\016\001\029\004\215\006%\000\196\001{\002\244\001}\001e\003\213\002\244\005\247\006\024\001#\003J\001#\001n\006\026\002\244\002\244\004\152\004\001\001\191\003\227\001\192\005 \005\249\006\028\001\179\006\150\002e\001\223\002k\001\173\005!\001\227\005\"\001\016\002q\001\253\001}\002g\001\t\006\029\001\t\002\r\002\014\001^\001\016\001\029\001\016\001\029\005\250\0007\006\136\002\244\001\024\001\t\004\t\005^\002Q\002s\001\181\001\016\001\029\004\002\006~\003\195\002R\001f\006\145\003\240\003\242\004\246\006J\001\228\001\024\0048\000\196\001\025\001g\002`\005$\000\193\001\178\004=\006s\005&\0050\001\229\000\196\005F\005G\0017\001\188\0017\001\024\005Z\005<\004\001\001\030\002\244\001\030\001\027\005_\002\b\005H\005X\002\r\002\014\001^\005P\004\001\005[\003k\001\030\006`\002\244\004\217\001\184\005?\000\193\006\180\002Q\000\196\006a\002\244\001'\002\011\001'\001A\002R\001A\003n\000m\004w\002\025\003\140\004\215\001z\002b\001\016\006|\001\230\002`\001\024\001#\001\150\001\025\001}\001e\002\017\001\201\002d\000\193\001\t\000\196\002(\002\244\001\239\005B\001\016\001\029\002\r\002\014\001^\002+\000\196\004U\001\203\0021\005\193\001\027\002F\000\193\001\t\005{\002K\002Q\001\239\001\024\001\016\001\029\002h\004a\003\205\002R\001@\001\252\005?\000\196\000\193\006\222\004d\001\219\001\t\001\226\000m\000\196\002`\003\188\001\016\001\029\002b\001\024\003\209\003\184\001\025\001\252\002\244\002e\000\193\002k\001\030\002\017\001#\002d\000\193\002q\000\196\001}\002g\005F\005G\005\185\004l\0017\002\163\000\196\006\152\001\239\001\027\000\196\001\030\003\196\000\196\006\224\005H\005X\000\196\001\031\002s\005P\004\001\001\t\002\007\002h\001\253\005?\005\217\001\016\001\029\000\193\001\030\003\202\001\191\004#\001\221\002b\001\252\001'\003\217\000\193\001A\001\223\003\234\002\244\001\253\001\227\002\017\001\016\002d\000\193\002e\001#\002k\004p\005\127\003\236\001\t\001)\002q\003\254\001}\002g\001\016\001\029\001\024\006\166\000\196\001\025\005F\005G\006Z\004\001\0017\000\196\002\n\004\003\001\024\004\"\002h\001\030\001\t\002s\002\024\005H\005X\001\228\001\016\001\029\005P\004\001\004(\001\027\004/\000\196\002'\001\253\002\r\002\014\001^\001\229\000\196\002*\0020\002<\000\196\002e\001'\002k\005?\001A\004x\002Q\0045\002q\001\030\001}\002g\000\196\0029\002R\001\191\000\196\001\247\002\244\004H\006O\004M\005F\005G\001\223\004X\0017\002`\001\227\001#\001\016\002s\000\196\001\030\000\196\002\244\003h\005H\005X\002\r\002\014\001^\005P\004\001\002\r\002\014\001^\000\196\000\189\000\196\004`\000\193\000\194\004c\002Q\002A\004j\004n\001\t\002Q\001'\004s\002R\001A\001\016\001\029\001\239\002R\001\228\000\196\001\t\004\127\006=\004\014\002@\002`\001\016\001\029\004\146\005\203\002`\000\196\001\229\000\196\002E\004\137\002b\000\196\002\r\002\014\001^\002J\004I\002\247\002p\001\252\002\167\002\017\000\193\002d\000\193\004\151\004\141\002Q\002\202\005F\005G\005\205\004\156\0017\002\209\002R\000\196\002\244\004\166\000\196\001\030\004\b\000\196\000\196\006\148\006\149\005\206\000\196\002`\005P\004\001\005\208\001\030\002h\002\238\005\219\002\244\000\196\002b\002\244\002\r\002\014\001^\002b\000\196\004\172\001\239\001'\003]\002\017\001A\002d\000\193\003e\002\017\002Q\002d\000\193\001\253\003\245\002e\002\244\002k\002R\001\191\004\183\002\029\000\196\002q\003\194\001}\002g\006D\001\223\000\196\001\252\002`\001\227\000\193\001\016\000\196\002h\003\154\004\198\004\195\003\164\002h\002b\003\186\004\216\004\202\002s\004\223\001\024\004\240\003\201\005\001\003\203\002\017\004\250\002d\000\193\005\019\004\228\002\244\002\244\004\233\000\196\002e\003\216\003\007\003\253\005(\002e\004\005\002k\002q\001\228\001}\002g\001\027\002q\002\244\001}\002g\004.\002\244\000\196\005\017\004'\002h\001\229\006\014\0052\001\253\002b\002\244\004)\004,\002s\002\r\002\014\001^\004;\002s\000\196\002\017\007\r\002d\000\193\007\014\000\196\000\196\006\017\000\196\002Q\000\196\002e\005>\002k\005R\000\196\006\018\002R\000\196\002q\005b\001}\002g\001\024\0041\005\025\005%\003\191\000\196\005h\002`\005l\002h\004:\005\136\002\r\002\014\001^\002\244\002\r\002\014\001^\002s\005-\002\244\006\019\001\t\005D\005\176\000\196\002Q\005\236\001\016\001\029\002Q\005\181\005\220\005u\002R\002e\002\244\002k\002R\005\186\003\177\0046\002\244\002q\003\129\001}\002g\002`\0049\004G\000\196\002`\000\196\000\189\004L\006\020\000\193\000\194\000\196\002\r\002\014\001^\001\191\006\021\003\207\002b\002s\000\196\005\216\000\196\004T\001\223\000\196\002\244\002Q\001\227\002\017\001\016\002d\000\193\001\030\005\152\002R\007\016\005\203\005\192\000\196\005\178\003|\000\196\002\244\004S\004W\000\196\000\196\002`\005\200\005\241\001\t\006\006\006C\000\196\006\023\005\189\001\016\001\029\002b\001'\002h\005\223\002b\006\024\005\205\004b\002\244\001\228\006\026\002\017\002\244\002d\000\193\002\017\002\244\002d\000\193\002\244\006\028\005\206\002\244\001\229\000\196\002\244\005\208\004m\006]\002e\005\237\003\007\004i\004r\005\235\002\244\006\029\002q\004\134\001}\002g\000\196\006i\002h\006w\001]\001^\002h\002b\002\244\001\030\005\239\000\196\000\196\004z\000\196\000\196\006y\002\244\002\017\002s\002d\000\193\004\133\002\244\001_\001o\004\128\001a\001b\002e\002\244\002k\004\132\002e\005\243\002k\003\251\002q\005\248\001}\002g\002q\006\004\001}\002g\006\011\002\244\003x\006\025\000\196\002h\006 \002\244\002\r\002\014\001^\004\145\002\r\002\014\001^\002s\006)\004\150\000\196\002s\000\196\004\249\001p\002Q\001q\002-\004\155\002Q\004\158\004\162\006n\002R\002e\000\196\002k\002R\004\170\003q\004\177\006\154\002q\003b\001}\002g\002`\006\168\004\188\004\248\002`\004\241\004\242\004\247\007\007\001x\002\r\002\014\001^\004\251\002\r\002\014\001^\004\252\005\027\002s\001g\005\020\005\021\000\193\007\018\002Q\005\026\005/\005+\002Q\007\023\003{\005,\002R\005.\005Y\005=\002R\000\189\003Z\005A\000\193\000\194\001\191\005C\004\022\002`\003R\005E\005Q\002`\005a\001\223\005c\005d\005i\001\227\005m\001\016\002b\001]\001^\005q\002b\005\131\005\138\005\142\005\166\005\187\005\203\002\017\005\211\002d\000\193\002\017\005\221\002d\000\193\006\r\001z\001_\001`\006\007\001a\001b\006\b\006\012\001{\006\027\001}\001e\006B\006M\006X\006l\006m\001\228\005\205\006q\006\153\006\157\006\167\002h\006\171\005\028\002b\002h\006\249\000\000\002b\001\229\000\000\005\206\002\r\002\014\001^\002\017\005\208\002d\000\193\002\017\006\000\002d\000\193\000\000\000\000\000\000\000\000\002Q\002e\000\000\002k\005\029\002e\005\030\002k\002R\002q\000\000\001}\002g\002q\002]\001}\002g\000\000\000\000\000\000\002h\002`\000\000\000\000\002h\000\000\001f\002\r\002\014\001^\000\000\000\000\002s\000\000\000\000\005\031\002s\001g\000\000\000\000\000\193\000\000\002Q\000\000\000\000\000\000\000\000\002e\000\000\002k\002R\002e\000\000\003\007\000\000\002q\002j\001}\002g\002q\000\000\001}\002g\002`\000\000\000\000\000\000\000\000\005 \002\r\002\014\001^\000\000\000\000\002\r\002\014\001^\005!\002s\005\"\002b\000\000\002s\000\000\002Q\000\000\001\191\000\000\004\026\002Q\000\000\002\017\002R\002d\000\193\001\223\001z\002R\002y\001\227\000\000\001\016\005\\\002x\001\150\002`\001}\001e\000\000\000\000\002`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\014\001^\002b\002h\000\000\005$\000\000\000\000\000\000\000\000\005&\0050\000\000\002\017\002Q\002d\000\193\000\000\000\000\001\228\005Z\000\000\002R\000\000\000\000\000\000\000\000\000\000\002\172\000\000\002e\000\000\002k\001\229\000\000\002`\005[\000\000\002q\000\000\001}\002g\000\000\000\000\002b\002h\000\000\000\000\000\000\002b\000\000\000\000\002\r\002\014\001^\002\017\000\000\002d\000\193\000\000\002\017\002s\002d\000\193\001\191\000\000\004\029\002Q\000\000\000\000\000\000\000\000\002e\001\223\002k\002R\000\000\001\227\000\000\001\016\002q\002\183\001}\002g\000\000\000\000\000\000\002h\002`\000\000\000\000\000\000\002h\000\000\002b\000\000\000\000\002\r\002\014\001^\001\191\000\000\004+\002s\000\000\002\017\000\000\002d\000\193\001\223\000\000\000\000\002Q\001\227\002e\001\016\002k\001\228\000\000\002e\002R\002k\002q\000\000\001}\002g\002\206\002q\000\000\001}\002g\001\229\000\000\002`\002\r\002\014\001^\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002s\000\000\002b\000\000\000\000\002s\000\000\000\000\001\228\000\000\000\000\000\000\003M\002\017\000\000\002d\000\193\001\024\000\000\002e\005\b\002k\001\229\002\r\002\014\001^\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\000\000\003N\000\000\002Q\000\000\000\000\002\r\002\014\001^\001\027\002h\002R\002b\000\000\000\000\002s\000\000\002\213\001\191\000\000\004|\002Q\000\000\002\017\002`\002d\000\193\001\223\000\000\002R\000\000\001\227\000\000\001\016\000\000\002\216\000\000\002e\000\000\002k\006\014\000\000\002`\000\000\000\000\002q\000\000\001}\002g\002\016\002\r\002\014\001^\000\000\000\000\002h\000\000\000\000\006\015\000\000\002\017\006\017\002d\000\193\000\000\002Q\000\000\000\000\002s\000\000\006\018\001\228\000\000\002R\000\000\000\000\000\000\000\000\000\000\002\222\000\000\001\t\002e\002b\002k\001\229\002`\001\016\001\029\000\000\002q\000\000\001}\002g\002\017\003P\002d\000\193\000\000\006\019\000\000\002b\002\r\002\014\001^\000\000\000\000\001\191\000\000\004\130\000\000\000\000\002\017\002s\002d\000\193\001\223\002Q\000\000\002e\001\227\000\000\001\016\000\000\000\000\002R\002h\002f\000\000\001}\002g\002\225\000\000\006\020\000\000\000\000\000\000\000\000\002`\001\030\000\000\006\021\000\000\000\000\002h\002b\000\000\002\r\002\014\001^\000\000\000\000\000\000\002e\000\000\002k\002\017\000\000\002d\000\193\001\228\002q\002Q\001}\002g\006\022\001'\000\000\000\000\000\000\002R\002e\000\000\002k\001\229\000\000\002\250\000\000\000\000\002q\006\023\001}\002g\002`\002s\000\000\000\000\000\000\002h\006\024\000\000\002\r\002\014\001^\006\026\000\000\000\000\002b\002\r\002\014\001^\000\000\002s\000\000\006\028\000\000\002Q\000\000\002\017\000\000\002d\000\193\000\000\002Q\002R\002e\000\000\002k\000\000\000\000\006\029\002R\000\000\002q\003\004\001}\002g\002`\000\000\000\000\000\000\003\t\000\000\000\000\002`\000\000\002\r\002\014\001^\000\000\002h\000\000\002b\002\r\002\014\001^\002s\000\000\001\191\000\000\004\139\000\000\000\000\002\017\000\000\002d\000\193\001\223\002Q\003M\000\000\001\227\000\000\001\016\000\000\000\000\002R\002e\000\000\002k\000\000\000\000\000\000\000\000\000\000\002q\003\011\001}\002g\002`\000\000\000\000\000\000\005\207\000\000\002h\002b\000\000\000\000\000\000\000\000\000\000\000\000\002b\002\r\002\014\001^\002\017\002s\002d\000\193\001\228\000\000\000\000\002\017\000\000\002d\000\193\000\000\002Q\000\000\000\000\002e\000\000\002k\001\229\000\000\002R\000\000\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\003\015\000\000\002h\002`\002\016\000\000\000\000\000\000\000\000\002h\000\000\002b\002\r\002\014\001^\002\017\002s\002d\000\193\002\r\002\014\001^\002\017\000\000\002d\000\193\000\000\002Q\000\000\002e\000\000\003\007\000\000\000\000\002Q\002R\002e\002q\003\007\001}\002g\000\000\002R\000\000\002q\003\023\001}\002g\002`\000\000\003P\000\000\003\029\000\000\002h\002`\000\000\000\000\000\000\000\000\002s\000\000\002b\002\r\002\014\001^\000\000\002s\000\000\000\000\000\000\000\000\000\000\002\017\002e\002d\000\193\000\000\002Q\000\000\000\000\002e\002f\003\007\001}\002g\002R\000\000\001\191\002q\004\147\001}\002g\000\000\000\000\000\000\003#\001\223\000\000\002`\000\000\001\227\000\000\001\016\000\000\002h\000\000\002b\002\r\002\014\001^\000\000\002s\000\000\002b\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\002Q\000\000\002\017\000\000\002d\000\193\000\000\000\000\002R\002e\000\000\003\007\000\000\000\000\003+\000\000\000\000\002q\001\228\001}\002g\002`\000\000\000\000\002\r\002\014\001^\002h\000\000\000\000\000\000\000\000\001\229\000\000\002h\002b\000\000\000\000\000\000\002Q\002s\000\000\000\000\000\000\000\000\000\000\002\017\002R\002d\000\193\000\000\000\000\000\000\0030\002e\000\000\003\007\000\000\000\000\000\000\002`\002e\002q\003\007\001}\002g\000\000\000\000\000\000\002q\000\000\001}\002g\001\191\000\000\006H\000\000\000\000\002h\000\000\002b\000\000\001\223\000\000\000\000\002s\001\227\000\000\001\016\000\000\000\000\002\017\002s\002d\000\193\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\003'\000\000\000\000\002Q\000\000\000\000\002q\000\000\001}\002g\000\000\002R\002b\002\r\002\014\001^\002h\000\000\000\000\001\228\000\000\003<\000\000\002\017\002`\002d\000\193\000\000\002Q\002s\000\000\000\000\000\000\001\229\000\000\000\000\002R\002\r\002\014\001^\000\000\000\000\000\000\002e\000\000\002k\003A\000\000\000\000\002`\000\000\002q\002Q\001}\002g\002h\000\000\000\000\000\000\000\000\002R\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\003F\000\000\000\000\002`\002s\000\000\000\000\002Q\000\000\000\000\000\000\000\000\002e\002b\002k\002R\000\000\002\r\002\014\001^\002q\000\000\001}\002g\002\017\003U\002d\000\193\002`\000\000\000\000\000\000\002Q\000\000\000\000\000\000\000\000\000\000\002b\000\000\002R\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\002\017\003X\002d\000\193\002`\000\000\000\000\002h\000\000\000\000\000\000\000\000\000\000\002b\002\r\002\014\001^\000\000\002\r\002\014\001^\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\002Q\000\000\000\000\002h\002Q\002e\000\000\003\007\002R\002b\000\000\000\000\002R\002q\003^\001}\002g\000\000\003`\000\000\002\017\002`\002d\000\193\000\000\002`\000\000\002h\000\000\000\000\002e\000\000\003\007\000\000\002b\000\000\002s\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\000\000\000\000\002h\000\000\002e\000\000\003\007\000\000\000\000\000\000\000\000\002s\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002h\000\000\002e\002b\003\007\000\000\000\000\002b\002s\000\000\002q\000\000\001}\002g\002\017\000\000\002d\000\193\002\017\000\000\002d\000\193\000\000\000\000\002\r\002\014\001^\002e\000\000\003'\000\000\000\000\000\000\002s\000\000\002q\000\000\001}\002g\002Q\002\r\002\014\001^\000\000\000\000\000\000\002h\002R\000\000\000\000\002h\000\000\000\000\003j\000\000\002Q\000\000\000\000\002s\000\000\002`\000\000\000\000\002R\000\000\000\000\002\r\002\014\001^\003s\000\000\000\000\000\000\002e\000\000\002k\002`\002e\000\000\002k\000\000\002q\000\000\001}\002g\002q\000\000\001}\002g\003\175\000\000\000\000\000\000\000\000\000\000\002\r\002\014\001^\000\000\000\000\002\r\002\014\001^\000\000\002s\000\000\000\000\000\000\002s\000\000\002Q\000\000\000\000\000\000\000\000\002Q\000\000\000\000\002R\002b\000\000\000\000\000\000\002R\003v\000\000\000\000\000\000\000\000\003\132\002\017\002`\002d\000\193\000\000\002b\002`\000\000\000\000\000\000\002\r\002\014\001^\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\000\000\000\000\000\000\000\000\002Q\000\000\000\000\000\000\000\000\000\000\002\016\002h\002R\000\000\000\000\000\000\000\000\000\000\003\135\000\000\000\000\002\017\000\000\002d\000\193\002`\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\002b\002k\000\000\000\000\000\000\002b\000\000\002q\000\000\001}\002g\002\017\000\000\002d\000\193\002e\002\017\002k\002d\000\193\000\000\000\000\000\000\002q\000\000\001}\002g\002\r\002\014\001^\002s\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\000\000\002e\002Q\002h\000\000\002b\002s\002Q\002h\002f\002R\001}\002g\000\000\000\000\002R\002\017\000\000\002d\000\193\003\145\000\000\000\000\002`\000\000\003\150\000\000\000\000\002`\000\000\002e\000\000\002k\000\000\000\000\002e\000\000\002k\002q\000\000\001}\002g\000\000\002q\000\000\001}\002g\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\002k\000\000\000\000\000\000\006\014\002b\002q\000\000\001}\002g\002b\000\000\000\000\002\r\002\014\001^\002\017\000\000\002d\000\193\000\000\002\017\006\015\002d\000\193\006\017\000\000\000\000\002Q\002s\000\000\002\r\002\014\001^\006\018\000\000\002R\000\000\000\000\000\000\000\000\000\000\003\199\000\000\000\000\000\000\002Q\000\000\002h\002`\000\000\000\000\000\000\002h\002R\000\000\000\000\000\000\000\000\000\000\003\212\000\000\000\000\006\019\002\r\002\014\001^\002`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\003\007\000\000\002Q\002e\000\000\003\007\002q\000\000\001}\002g\002R\002q\000\000\001}\002g\000\000\004\000\000\000\000\000\000\000\006\020\000\000\000\000\002`\000\000\000\000\000\000\000\000\006\021\002s\000\000\002b\000\000\000\000\002s\000\000\002\r\002\014\001^\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\000\000\000\000\002b\000\000\002Q\006!\000\000\000\000\000\000\000\000\000\000\000\000\002R\002\017\000\000\002d\000\193\000\000\004C\000\000\006\023\000\000\000\000\000\000\000\000\002`\000\000\002h\000\000\006\024\000\000\000\000\000\000\000\000\006\026\002b\000\000\000\000\000\000\000\000\002\r\002\014\001^\000\000\006\028\002h\002\017\000\000\002d\000\193\000\000\000\000\000\000\000\000\002e\002Q\002k\000\000\000\000\000\000\006\029\000\000\002q\002R\001}\002g\001]\001^\000\000\005p\000\000\000\000\002e\000\000\002k\000\000\002`\000\000\002h\000\000\002q\000\000\001}\002g\002b\002s\001_\001o\000\000\001a\001b\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\000\000\000\000\000\000\002s\000\000\002e\000\000\002k\000\000\004\016\000\000\000\000\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\001\024\000\000\000\000\005\005\000\000\000\000\000\000\002h\000\000\001p\000\000\001q\002-\000\000\000\000\002b\002s\000\000\000\000\000\000\002\r\002\014\001^\000\000\000\000\000\000\002\017\001\027\002d\000\193\000\000\000\000\000\000\000\000\002e\002Q\002k\002\r\002\014\001^\001x\000\000\002q\002R\001}\002g\000\000\000\000\000\000\005s\000\000\001g\002Q\000\000\000\193\000\000\002`\000\000\002h\000\000\002R\000\000\003{\000\000\000\000\002s\005\130\000\000\000\000\000\000\005\007\000\000\000\000\002`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\002k\000\000\000\000\000\000\000\000\000\000\002q\000\000\001}\002g\000\000\000\000\001\t\000\000\000\000\000\000\000\000\000\000\001\016\005\n\000\000\000\000\000\000\001z\000\000\002\r\002\014\001^\002b\002s\000\000\001{\000\000\001}\001e\000\000\000\000\000\000\000\000\002\017\002Q\002d\000\193\000\000\000\000\002b\000\000\000\000\002R\002\r\002\014\001^\000\000\000\000\005\133\000\000\002\017\000\000\002d\000\193\000\000\002`\000\000\000\000\002Q\000\000\002\r\002\014\001^\000\000\005\011\002h\002R\000\000\000\000\000\000\000\000\000\000\005\146\000\000\001\024\002Q\004\213\001\025\005\016\002`\005\r\000\000\002h\002R\000\000\000\000\000\000\000\000\000\000\005\149\000\000\001'\002e\000\000\002k\000\000\002`\000\000\000\000\000\000\002q\001\027\001}\002g\000\000\000\000\000\000\000\000\000\000\002e\000\000\002k\000\000\000\000\002b\000\000\000\000\002q\000\000\001}\002g\000\000\000\000\002s\000\000\002\017\000\000\002d\000\193\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\014\001^\002b\000\000\002s\000\000\000\000\000\000\001#\000\000\000\000\000\000\000\000\002\017\002Q\002d\000\193\000\000\000\000\002b\000\000\002h\002R\000\000\002\r\002\014\001^\000\000\005\170\000\000\002\017\000\000\002d\000\193\000\000\002`\000\000\001\t\000\000\002Q\002\r\002\014\001^\001\016\001\029\002h\000\000\002R\002e\000\000\002k\000\000\000\000\005\173\000\000\002Q\002q\000\000\001}\002g\002`\000\000\002h\002R\000\000\000\000\000\000\000\000\000\000\005\177\000\000\000\000\002e\000\000\002k\000\000\002`\000\000\000\000\002s\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\0017\002e\000\000\002k\000\000\006\014\002b\001\030\000\000\002q\000\000\001}\002g\000\000\000\000\002s\000\000\002\017\000\000\002d\000\193\000\000\000\000\006\015\000\000\000\000\006\017\000\000\000\000\000\000\000\000\002b\002s\000\000\001'\006\018\000\000\0018\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\002b\000\000\002h\000\000\000\000\002\r\002\014\001^\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\000\000\006\019\000\000\000\000\002Q\000\000\000\000\000\000\001]\001^\000\000\002h\002R\002e\000\000\002k\000\000\000\000\006\184\000\000\000\000\002q\000\000\001}\002g\002`\000\000\002h\001_\001o\000\000\001a\001b\000\000\000\000\006\020\000\000\000\000\002e\000\000\002k\000\000\000\000\006\021\002s\000\000\002q\000\000\001}\002g\000\000\006R\000\000\000\000\002e\000\000\002k\000\000\000\000\000\000\000\000\000\000\002q\000\000\001}\002g\000\000\006*\000\000\002s\000\000\001p\000\000\001q\002-\000\000\000\000\000\000\002\r\002\014\001^\000\000\006\023\000\000\002b\002s\000\000\000\000\000\000\000\000\000\000\006\024\000\000\002Q\000\000\002\017\006\026\002d\000\193\000\000\000\000\002R\001x\002\r\002\014\001^\006\028\006\186\000\000\000\000\000\000\000\000\000\000\001g\002`\000\000\000\193\000\000\002Q\002\r\002\014\001^\006\029\000\000\003{\000\000\002R\002h\000\000\001]\001^\000\000\000\000\000\000\002Q\000\000\000\000\000\000\000\000\002`\000\000\000\000\002R\001\024\000\000\000\000\005\005\000\000\000\000\001_\001o\000\000\001a\001b\002e\002`\002k\000\000\000\000\001\159\000\000\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\001\027\000\000\001z\002b\000\000\000\000\000\000\000\000\000\000\000\000\001{\000\000\001}\001e\002\017\002s\002d\000\193\000\000\000\000\000\000\000\000\001p\000\000\001q\001\146\000\000\000\000\002b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\005\007\002b\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\001x\000\000\002\017\000\000\002d\000\193\000\000\000\000\000\000\000\000\000\000\001g\000\000\000\000\000\193\000\000\000\000\000\000\002h\001\t\002e\000\000\002k\000\000\000\000\001\016\005\n\000\000\002q\000\000\001}\002g\000\000\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\004\017\000\000\000\000\000\000\002s\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\002e\000\000\004\r\001]\001^\000\000\000\000\000\000\002q\001z\001}\002g\000\000\000\000\000\000\002s\005\011\001{\000\000\001}\001e\001]\001^\001_\001o\000\000\001a\001b\004\213\000\000\005\015\002s\005\r\001\143\000\000\002\r\002\014\001^\000\000\000\000\000\000\001_\001o\001'\001a\001b\000\000\000\000\000\000\000\000\002Q\001\148\000\000\001]\001^\000\000\000\000\000\000\002R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001p\000\000\001q\001\146\000\000\002`\000\000\001_\001o\000\000\001a\001b\000\000\000\000\000\000\002\r\002\014\001^\001p\000\000\001q\001\146\000\000\001]\001^\000\000\000\000\000\000\000\000\000\000\002Q\001x\000\000\000\000\000\000\000\000\000\000\000\000\002R\000\000\000\000\000\000\001g\001_\001o\000\193\001a\001b\000\000\001x\001p\002`\001q\002-\000\000\000\000\000\000\000\000\000\000\000\000\001g\000\000\000\000\000\193\002b\000\000\000\000\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\000\000\001x\000\000\002Q\000\000\000\000\001p\000\000\001q\0025\000\000\002R\001g\000\000\000\000\000\193\000\000\000\000\000\000\000\000\000\000\001z\000\000\003w\002`\000\000\000\000\002h\000\000\001{\002b\001}\001e\000\000\000\000\000\000\000\000\001x\000\000\001z\000\000\002\017\000\000\002d\000\193\000\000\000\000\001{\001g\001}\001e\000\193\000\000\000\000\002e\000\000\003\183\000\000\000\000\000\000\000\000\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\000\000\001z\000\000\002h\000\000\000\000\000\000\000\000\0028\001{\000\000\001}\001e\002b\000\000\002s\002\r\002\014\001^\000\000\000\000\002\r\002\014\001^\002\017\000\000\002d\000\193\000\000\000\000\002e\002Q\003Q\000\000\000\000\000\000\002Q\001z\002q\002R\001}\002g\000\000\000\000\002R\001{\000\000\001}\001e\000\000\000\000\000\000\002`\000\000\000\000\000\000\002h\002`\000\000\000\000\000\000\002s\000\000\002\r\002\014\001^\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002Q\000\000\000\000\000\000\002Q\002e\000\000\002\248\002R\000\000\000\000\000\000\002R\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\002`\000\000\000\000\000\000\002`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002b\000\000\000\000\002s\000\000\002b\000\000\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\002\017\000\000\002d\000\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\014\001^\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002Q\002h\000\000\000\000\002Q\002b\002h\000\000\002R\002b\000\000\000\000\002R\000\000\000\000\000\000\002\017\000\000\002d\000\193\002\017\002`\002d\000\193\000\000\002`\000\000\000\000\002e\000\000\002m\000\000\000\000\002e\000\000\002o\002q\000\000\001}\002g\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\002h\000\000\000\000\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\002t\000\000\002e\002b\002{\000\000\002q\002b\001}\002g\002q\000\000\001}\002g\002\017\000\000\002d\000\193\002\017\000\000\002d\000\193\002\r\002\014\001^\000\000\002\r\002\014\001^\002s\000\000\000\000\000\000\002s\000\000\000\000\000\000\002Q\002\r\002\014\001^\002Q\000\000\000\000\000\000\002R\002h\000\000\000\000\002R\002h\000\000\000\000\002Q\000\000\000\000\000\000\000\000\002`\000\000\000\000\002R\002`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\002`\002}\000\000\002e\000\000\002\127\000\000\002q\000\000\001}\002g\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\014\001^\002s\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002Q\002b\000\000\000\000\000\000\002b\000\000\000\000\002R\000\000\000\000\000\000\002\017\000\000\002d\000\193\002\017\002b\002d\000\193\000\000\002`\000\000\000\000\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\002\r\002\014\001^\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\002h\000\000\000\000\002Q\002h\000\000\000\000\002Q\000\000\000\000\000\000\002R\000\000\000\000\000\000\002R\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002`\000\000\000\000\002e\002`\002\129\000\000\002e\000\000\002\131\000\000\002q\002b\001}\002g\002q\000\000\001}\002g\002e\000\000\002\133\000\000\002\017\000\000\002d\000\193\002q\000\000\001}\002g\000\000\000\000\000\000\002s\000\000\000\000\000\000\002s\002\r\002\014\001^\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\002s\000\000\000\000\000\000\002Q\002h\000\000\000\000\002Q\002b\000\000\000\000\002R\002b\000\000\000\000\002R\000\000\000\000\000\000\002\017\000\000\002d\000\193\002\017\002`\002d\000\193\000\000\002`\000\000\000\000\002e\000\000\002\135\002\r\002\014\001^\000\000\000\000\002q\000\000\001}\002g\000\000\000\000\001\024\000\000\000\000\001\025\002Q\000\000\002h\000\000\000\000\000\000\002h\000\000\002R\000\000\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002`\000\000\001\027\000\000\006\133\000\000\000\000\000\000\002e\000\000\002\137\000\000\002e\002b\002\139\000\000\002q\002b\001}\002g\002q\000\000\001}\002g\002\017\000\000\002d\000\193\002\017\000\000\002d\000\193\000\000\000\000\000\000\002\r\002\014\001^\000\000\002s\002\r\002\014\001^\002s\000\000\001#\000\000\000\000\000\000\000\000\002Q\000\000\000\000\000\000\000\000\002Q\002h\000\000\002R\002b\002h\000\000\000\000\002R\000\000\000\000\000\000\000\000\000\000\000\000\002\017\002`\002d\000\193\001\t\000\000\002`\000\000\000\000\000\000\001\016\001\029\000\000\002e\000\000\002\141\000\000\002e\000\000\002\143\000\000\002q\000\000\001}\002g\002q\000\000\001}\002g\000\000\000\000\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\014\001^\002s\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\000\000\0017\002Q\000\000\000\000\002e\002b\002\145\001\030\000\000\002R\002b\006\140\002q\000\000\001}\002g\002\017\000\000\002d\000\193\000\000\002\017\002`\002d\000\193\000\000\002\r\002\014\001^\000\000\000\000\002\r\002\014\001^\001'\002s\000\000\001A\000\000\000\000\000\000\002Q\000\000\000\000\000\000\000\000\002Q\000\000\002h\002R\000\000\000\000\000\000\002h\002R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002`\000\000\000\000\000\000\000\000\002`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\002\147\000\000\000\000\002e\002b\002\149\002q\000\000\001}\002g\000\000\002q\000\000\001}\002g\002\017\000\000\002d\000\193\000\000\000\000\000\000\000\000\000\000\000\000\002\r\002\014\001^\000\000\002s\000\000\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\002Q\000\000\000\000\000\000\002b\000\000\000\000\002h\002R\002b\000\000\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\002\017\002`\002d\000\193\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\002\151\000\000\000\000\000\000\002Q\000\000\002q\000\000\001}\002g\000\000\002h\002R\000\000\000\000\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002`\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\002\153\000\000\000\000\002e\002b\002\155\002q\000\000\001}\002g\000\000\002q\000\000\001}\002g\002\017\000\000\002d\000\193\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\000\000\002s\000\000\000\000\000\000\000\000\002s\002Q\000\000\000\000\000\000\002\164\001^\000\000\000\000\002R\002b\000\000\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\017\002`\002d\000\193\002\218\001o\000\000\001a\001b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001]\001^\000\000\002e\000\000\002\157\000\000\000\000\000\000\002\181\000\000\002q\000\000\001}\002g\000\000\002h\002\184\001]\001^\001_\002\185\000\000\001a\001b\000\000\000\000\002\181\000\000\000\000\002\223\002\239\002\240\000\000\002s\002\184\000\000\000\000\001_\002\185\000\000\001a\001b\002e\002b\002\159\002\r\002\014\001^\000\000\000\000\002q\000\000\001}\002g\002\017\000\000\002d\000\193\000\000\006\014\002Q\001x\000\000\000\000\000\000\000\000\000\000\000\000\002R\000\000\000\000\000\000\001g\002s\007\r\000\193\000\000\007\014\000\000\000\000\006\017\002`\000\000\000\000\000\000\000\000\002h\000\000\000\000\006\018\000\000\000\000\000\000\001f\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001g\002\243\000\000\000\193\000\000\000\000\000\000\001f\000\000\002e\000\000\002\161\000\000\000\000\006\019\000\000\000\000\002q\001g\001}\002g\000\193\000\000\000\000\000\000\000\000\000\000\001z\000\000\000\000\002\r\002\014\001^\000\000\002\186\001{\002b\001}\001e\000\000\002s\001\024\000\000\000\000\005\005\002Q\000\000\002\017\006\020\002d\000\193\000\000\002\186\002R\002\188\000\000\006\021\000\000\000\000\001z\000\000\000\000\000\000\002\r\002\014\001^\002`\001\150\001\027\001}\001e\000\000\002\187\000\000\000\000\000\000\007\015\001z\002Q\002h\000\000\000\000\002\r\002\014\001^\001\150\002R\001}\001e\000\000\000\000\000\000\000\000\000\000\000\000\006\023\000\000\002Q\000\000\002`\000\000\000\000\000\000\000\000\006\024\002R\002e\000\000\002\254\006\026\000\000\005\007\000\000\000\000\002q\000\000\001}\002g\002`\006\028\000\000\000\000\000\000\000\000\000\000\002b\002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\000\000\006\029\002\017\002s\002d\000\193\001\t\002Q\002\r\002\014\001^\000\000\001\016\005\n\000\000\002R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002Q\002b\000\000\000\000\000\000\002`\000\000\000\000\002R\000\000\000\000\002h\002\017\000\000\002d\000\193\000\000\000\000\000\000\000\000\002b\002`\000\000\000\000\002\r\002\014\001^\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\000\000\000\000\000\000\002e\002Q\003\027\005\011\000\000\000\000\002h\000\000\002q\002R\001}\002g\000\000\000\000\000\000\004\213\000\000\005\014\000\000\005\r\000\000\000\000\002`\000\000\000\000\002h\002b\000\000\000\000\000\000\001'\002s\000\000\002e\000\000\003!\000\000\002\017\005\028\002d\000\193\002q\002b\001}\002g\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\002\017\003&\002d\000\193\002\r\002\014\001^\002q\000\000\001}\002g\002s\000\000\005\029\006\192\005\030\002h\000\000\000\000\002Q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002R\002b\000\000\002s\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\002\017\002`\002d\000\193\002e\005\031\003.\000\000\000\000\000\000\000\000\000\000\002q\000\000\001}\002g\000\000\000\000\000\000\000\000\002e\000\000\0033\000\000\000\000\000\000\000\000\000\000\002q\000\000\001}\002g\002h\000\000\000\000\002s\000\000\000\000\005 \002\r\002\014\001^\000\000\000\000\000\000\000\000\000\000\005!\000\000\005\"\000\000\002s\000\000\000\000\002Q\000\000\000\000\000\000\000\000\002e\002b\0035\002R\002\r\002\014\001^\000\000\002q\000\000\001}\002g\002\017\005^\002d\000\193\002`\000\000\000\000\002Q\002\r\002\014\001^\000\000\000\000\001\024\000\000\002R\001\025\000\000\000\000\002s\002\r\002\014\001^\002Q\005$\006\194\001]\001^\002`\005&\0050\002R\002h\000\000\000\000\002Q\000\000\000\000\000\000\005Z\001\027\000\000\000\000\002R\002`\000\000\001_\001o\000\000\001a\001b\000\000\000\000\000\000\000\000\005[\002`\000\000\000\000\002e\000\000\0038\000\000\002b\000\000\000\000\000\000\002q\000\000\001}\002g\002\r\002\014\001^\002\017\000\000\002d\000\193\000\000\000\000\000\000\006\014\000\000\001#\000\000\000\000\002Q\002b\000\000\001p\002s\001q\002-\000\000\002R\000\000\007\r\000\000\002\017\007\014\002d\000\193\006\017\002b\000\000\000\000\002h\002`\000\000\000\000\000\000\006\018\001\t\000\000\002\017\002b\002d\000\193\001\016\001\029\001x\000\000\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\002h\001g\000\000\002e\000\193\003?\000\000\000\000\000\000\000\000\006\019\002q\003z\001}\002g\000\000\002h\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\002h\003D\000\000\000\000\000\000\006\132\002s\002q\002b\001}\002g\000\000\001\030\000\000\000\000\002e\006\020\003I\000\000\002\017\000\000\002d\000\193\002q\006\021\001}\002g\002e\000\000\003L\002s\000\000\001z\002\164\001^\002q\000\000\001}\002g\001'\001{\000\000\001}\001e\007\019\000\000\002s\002\r\002\014\001^\000\000\002h\000\000\002\218\001o\000\000\001a\001b\002s\000\000\000\000\000\000\002Q\006\023\000\000\000\000\000\000\000\000\000\000\000\000\002R\000\000\006\024\000\000\000\000\000\000\000\000\006\026\002e\000\000\003~\002\164\001^\002`\000\000\000\000\002q\006\028\001}\002g\000\000\000\000\000\000\000\000\000\000\002\223\002\239\002\240\002\164\001^\000\000\002\218\001o\006\029\001a\001b\000\000\000\000\000\000\002s\002\164\001^\000\000\000\000\000\000\000\000\001]\001^\002\218\001o\000\000\001a\001b\000\000\000\000\000\000\000\000\001x\000\000\000\000\002\218\001o\000\000\001a\001b\000\000\001_\001o\001g\001a\001b\000\193\002b\002\223\002\239\002\240\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\017\000\000\002d\000\193\002\r\002\014\001^\002\223\002\239\002\240\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\137\002\223\002\239\002\240\001x\000\000\000\000\000\000\001p\002\015\001q\006\238\000\000\006\240\002h\001g\000\000\000\000\000\193\000\000\000\000\001x\000\000\000\000\000\000\000\000\001z\000\000\000\000\000\000\000\000\000\000\001g\001x\001{\000\193\001}\001e\000\000\001x\000\000\002e\000\000\003\128\001g\000\000\000\000\000\193\004\006\002q\001g\001}\002g\000\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\188\001]\001^\000\000\000\000\000\000\000\000\002s\000\000\001z\000\000\000\000\005\222\000\000\000\000\000\000\002\016\001{\000\000\001}\001e\001_\001o\000\000\001a\001b\001z\002\017\000\000\002d\000\193\000\000\000\000\000\000\001{\000\000\001}\001e\001z\000\000\000\000\000\000\000\000\000\000\001z\000\000\001{\001\024\001}\001e\001\025\000\000\001{\001+\001}\001e\001\024\000\000\000\000\001\025\000\000\000\000\001+\000\000\001p\000\000\001q\0063\000\000\000\000\000\000\000\000\000\000\001,\001\027\000\000\000\000\000\000\000\000\000\000\001-\000\000\001,\001\027\001]\001^\002e\000\000\000\000\001F\000\000\001]\001^\000\000\002f\001x\001}\002g\000\000\000\000\000\000\000\000\000\000\000\000\001_\001o\001g\001a\001b\000\193\000\000\001_\001o\000\000\001a\001b\000\000\001#\001]\001^\000\000\000\000\000\000\000\000\000\000\000\000\001#\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0011\000\000\000\000\000\000\001_\001o\000\000\001a\001b\0011\000\000\000\000\001\t\001p\000\000\001q\001\151\000\000\001\016\001\029\001p\001\t\001q\001\129\000\000\000\000\000\000\001\016\001\029\000\000\000\000\001z\000\000\001]\001^\000\000\000\000\000\000\000\000\001{\000\000\001}\001e\000\000\001x\000\000\000\000\001p\000\000\001q\001~\001x\000\000\001_\001o\001g\001a\001b\000\193\000\000\000\000\000\000\001g\0017\000\000\000\193\000\000\000\000\000\000\000\000\001\030\000\000\0017\000\000\001?\000\000\000\000\000\000\001x\001\030\000\000\001]\001^\001?\000\000\000\000\000\000\001]\001^\001g\000\000\000\000\000\193\000\000\000\000\000\000\001p\001'\001q\001s\001A\001_\001o\000\000\001a\001b\001'\001_\001o\001A\001a\001b\000\000\000\000\001z\000\000\000\000\000\000\000\000\001]\001^\001z\001{\000\000\001}\001e\000\000\001x\000\000\001{\000\000\001}\001e\000\000\000\000\000\000\000\000\000\000\001g\001_\001o\000\193\001a\001b\001p\000\000\001q\001v\001z\000\000\001p\000\000\001q\001y\000\000\000\000\001{\000\000\001}\001e\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001]\001^\000\000\000\000\000\000\001x\000\000\000\000\000\000\000\000\000\000\001x\001p\000\000\001q\001|\001g\000\000\000\000\000\193\001_\001o\001g\001a\001b\000\193\000\000\001z\000\000\000\000\000\000\000\000\001]\001^\000\000\001{\000\000\001}\001e\000\000\000\000\000\000\000\000\001x\000\000\000\000\000\000\000\000\000\000\001]\001^\000\000\001_\001o\001g\001a\001b\000\193\000\000\000\000\000\000\000\000\000\000\001p\000\000\001q\001\134\000\000\000\000\001_\001o\000\000\001a\001b\000\000\001z\000\000\000\000\000\000\001]\001^\001z\000\000\001{\000\000\001}\001e\000\000\002\214\001{\000\000\001}\001e\000\000\001x\001p\002\217\001q\001\137\001_\002\185\000\000\001a\001b\000\000\001g\000\000\000\000\000\193\000\000\000\000\000\000\001p\001z\001q\002G\000\000\000\000\000\000\000\000\000\000\001{\000\000\001}\001e\000\000\001x\000\000\001]\001^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001g\000\000\000\000\000\193\000\000\000\000\001x\000\000\000\000\000\000\000\000\001_\001o\000\000\001a\001b\000\000\001g\000\000\000\000\000\193\000\000\000\000\000\000\000\000\001]\001^\001z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001{\001f\001}\001e\000\000\000\000\000\000\001]\001^\000\000\001_\001o\001g\001a\001b\000\193\000\000\000\000\000\000\001p\000\000\001q\002\228\000\000\001z\000\000\000\000\001_\001o\000\000\001a\001b\001{\000\000\001}\001e\000\000\000\000\000\000\001]\001^\001z\000\000\000\000\000\000\000\000\002\186\000\000\000\000\001{\001x\001}\001e\001p\000\000\001q\002\231\000\000\000\000\001_\001o\001g\001a\001b\000\193\000\000\002\r\002\014\001^\000\000\001p\001z\001q\002\234\000\000\000\000\000\000\000\000\000\000\001\150\000\000\001}\001e\000\000\001x\000\000\001]\001^\000\000\002L\001\024\000\000\000\000\001\025\000\000\001g\001B\000\000\000\193\000\000\000\000\001x\001p\000\000\001q\002\242\001_\001o\000\000\001a\001b\000\000\001g\000\000\000\000\000\193\001D\001\027\000\000\000\000\001z\000\000\004\206\000\000\000\000\000\000\000\000\000\000\001{\001\024\001}\001e\001\025\001x\000\000\001B\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001g\000\000\000\000\000\193\000\000\001p\000\000\001q\004A\000\000\001z\001D\001\027\000\000\000\000\000\000\001#\002\016\001{\000\000\001}\001e\000\000\000\000\000\000\000\000\000\000\001z\002\017\000\000\002d\000\193\000\000\0011\000\000\001{\001x\001}\001e\000\000\000\000\000\000\001]\001^\000\000\001\t\000\000\001g\000\000\000\000\000\193\001\016\001\029\000\000\001\024\001#\000\000\001\025\000\000\001z\001+\000\000\001_\002\185\000\000\001a\001b\001{\000\000\001}\001e\000\000\0011\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0010\001\027\000\000\000\000\001\t\000\000\000\000\002e\001]\001^\001\016\001\029\000\000\000\000\000\000\002f\0017\001}\002g\000\000\000\000\000\000\000\000\001\030\000\000\000\000\001z\005\004\001_\002\185\000\000\001a\001b\000\000\001{\000\000\001}\001e\000\000\000\000\000\000\000\000\000\000\000\000\001#\000\000\000\000\000\000\001]\001^\001'\000\000\000\000\001A\000\000\0017\001f\000\000\000\000\000\000\000\000\0011\001\030\001]\001^\000\000\001?\001g\001_\002\185\000\193\001a\001b\001\t\000\000\000\000\001]\001^\000\000\001\016\001\029\000\000\000\000\001_\002\185\000\000\001a\001b\000\000\001'\000\000\000\000\001A\005\150\000\000\000\000\001_\002\185\000\000\001a\001b\003k\001f\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001g\000\000\000\000\000\193\000\000\000\000\000\000\003m\000\000\000\000\000\000\0017\000\000\001z\000\000\000\000\000\000\000\000\001\030\000\000\000\000\001\150\001?\001}\001e\000\000\000\000\000\000\000\000\001f\000\000\000\000\000\000\000\000\003k\000\000\000\000\000\000\000\000\000\000\001g\000\000\000\000\000\193\001f\001'\000\000\000\000\001A\000\000\000\000\000\000\000\000\003l\000\000\001g\000\000\001f\000\193\001z\001]\001^\000\000\000\000\000\000\000\000\000\000\001\150\001g\001}\001e\000\193\000\000\000\000\003k\000\000\000\000\005\174\000\000\000\000\001_\002\185\000\000\001a\001b\000\000\000\000\000\000\000\000\006\001\000\000\000\000\000\000\003p\000\000\000\000\000\000\001]\001^\001z\000\000\000\000\002\186\000\000\000\000\000\000\000\000\001\150\000\000\001}\001e\000\000\000\000\000\000\001z\000\000\000\000\001_\002\185\000\000\001a\001b\001\150\000\000\001}\001e\000\000\001z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\150\006\003\001}\001e\001]\001^\000\000\000\000\000\000\000\000\000\000\001]\001^\000\000\000\000\000\000\001]\001^\000\000\001f\000\000\000\000\000\000\000\000\001_\002\185\000\000\001a\001b\000\000\001g\001_\002\185\000\193\001a\001b\001_\002\185\000\000\001a\001b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001]\001^\001f\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\186\000\000\005\028\001g\000\000\000\000\000\193\000\000\000\000\000\000\001_\002\185\000\000\001a\001b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001z\000\000\000\000\000\000\000\000\005\029\006\174\005\030\001\150\001f\001}\001e\005\201\000\000\000\000\001\024\001f\000\000\001\025\000\000\001g\001f\000\000\000\193\000\000\000\000\000\000\001g\000\000\000\000\000\193\000\000\001g\000\000\000\000\000\193\005\031\001z\000\000\000\000\000\000\000\000\001\027\000\000\000\000\001\150\000\000\001}\001e\000\000\000\000\000\000\004\191\000\000\005\201\000\000\000\000\000\000\005\214\001f\000\000\006\001\000\000\000\000\000\000\000\000\006\001\005\147\001\024\005 \001g\001\025\000\000\000\193\000\000\000\000\000\000\000\000\005!\001z\005\"\000\000\000\000\000\000\000\000\001#\001z\001\150\000\000\001}\001e\001z\000\000\000\000\001\150\001\027\001}\001e\000\000\001\150\005\213\001}\001e\005^\003o\003\230\000\000\001\024\006\002\001\024\001\025\000\000\001\025\006\n\001\t\000\000\000\000\000\000\000\000\006v\001\016\001\029\000\000\000\000\000\000\000\000\005$\000\000\000\000\001z\000\000\005&\0050\006\014\001\027\000\000\001\027\001\150\001#\001}\001e\005Z\000\000\000\000\004\191\000\000\004\191\000\000\007\r\000\000\000\000\007\014\000\000\000\000\006\017\000\000\000\000\005[\000\000\005\161\000\000\005\171\000\000\006\018\000\000\0017\000\000\001\t\000\000\000\000\000\000\000\000\001\030\001\016\001\029\000\000\004\196\001#\000\000\001#\001]\001^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\019\000\000\002\r\002\014\001^\000\000\000\000\001'\001_\002\170\001A\001a\001b\000\000\001\t\000\000\001\t\000\000\000\000\000\000\001\016\001\029\001\016\001\029\001\024\003M\0017\001\025\000\000\000\000\000\000\000\000\000\000\001\030\006\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\021\001\024\000\000\000\000\001\025\000\000\000\000\000\000\000\000\001\027\001\024\000\000\000\000\001\025\000\000\000\000\000\000\000\000\001'\002\207\007\024\003\237\000\000\0017\000\000\0017\000\000\000\000\001\027\000\000\001\030\000\000\001\030\000\000\004\196\000\000\004\196\001\027\000\000\006\023\001f\000\000\000\000\000\000\000\000\000\000\005\028\003\230\006\024\000\000\000\000\001g\001#\006\026\000\193\002\016\000\000\001'\000\000\001'\001A\003\233\001A\006\028\000\000\000\000\002\017\000\000\002d\000\193\000\000\001#\001\024\000\000\005\029\001\025\005\030\000\000\000\000\006\029\001#\001\t\000\000\000\000\000\000\000\000\000\000\001\016\001\029\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\027\001\t\003O\000\000\000\000\005\196\005\031\001\016\001\029\000\000\001\t\001z\000\000\000\000\000\000\001\024\001\016\001\029\001\025\001\150\000\000\001}\001e\000\000\000\000\000\000\002e\001\024\000\000\000\000\001\025\000\000\000\000\0017\002f\000\000\001}\002g\000\000\005 \001\030\000\000\001\027\001#\002\178\000\000\000\000\000\000\005!\000\000\005\"\000\000\0017\000\000\001\027\000\000\000\000\000\000\000\000\001\030\000\000\0017\000\000\004\224\000\000\000\000\004\227\001'\001\030\006\014\001A\000\000\001\t\005#\000\000\000\000\000\000\000\000\001\016\001\029\000\000\001\024\000\000\000\000\001\025\001#\001'\007\004\000\000\001A\006\017\001\024\000\000\006\218\001\025\001'\005$\001#\003\237\006\018\000\000\005&\0050\000\000\000\000\000\000\000\000\000\000\001\027\000\000\000\000\005Z\000\000\000\000\001\t\000\000\000\000\000\000\001\027\000\000\001\016\001\029\001\024\0017\000\000\001\025\001\t\005[\006\019\000\000\001\030\000\000\001\016\001\029\004\211\000\000\000\000\000\000\000\000\000\000\001\024\000\000\000\000\001\025\000\000\000\000\000\000\000\000\000\000\001\027\000\000\001#\000\000\000\000\000\000\001\024\000\000\001'\001\025\000\000\001A\001#\006\020\000\000\000\000\0017\000\000\001\027\000\000\000\000\006\021\000\000\001\030\000\000\000\000\0015\004\224\0017\000\000\005\242\001\t\000\000\001\027\000\000\001\030\000\000\001\016\001\029\006\219\000\000\001\t\007\005\001#\000\000\000\000\000\000\001\016\001\029\000\000\001'\000\000\000\000\001A\000\000\000\000\000\000\000\000\000\000\000\000\006\023\001#\001'\000\000\000\000\001A\000\000\001\024\000\000\006\024\001\025\000\000\001\t\000\000\006\026\000\000\001#\001\024\001\016\001\029\001\025\000\000\0017\000\000\006\028\000\000\000\000\000\000\000\000\001\030\001\t\000\000\0017\006\179\001\027\001\024\001\016\001\029\001\025\001\030\006\029\000\000\000\000\001Q\001\027\001\t\000\000\000\000\000\000\000\000\000\000\001\016\001\029\002\r\002\014\001^\001'\000\000\000\000\001A\000\000\000\000\001\027\0017\000\000\000\000\001'\000\000\000\000\001A\001\030\002\r\002\014\001^\001\167\000\000\002N\001#\002\r\002\014\001^\0017\000\000\000\000\000\000\000\000\000\000\001#\001\030\000\000\000\000\000\000\000\000\000\000\002X\000\000\0017\001'\000\000\000\000\001A\002c\000\000\001\030\000\000\001#\001\t\001\205\002\r\002\014\001^\000\000\001\016\001\029\000\000\001'\001\t\000\000\001=\000\000\000\000\000\000\001\016\001\029\000\000\001\024\000\000\000\000\001\025\000\000\001'\002r\000\000\001A\001\t\000\000\000\000\000\000\000\000\000\000\001\016\001\029\000\000\001\024\000\000\000\000\001\025\000\000\002\016\000\000\000\000\000\000\001\027\000\000\000\000\000\000\000\000\0017\000\000\002\017\000\000\002d\000\193\000\000\001\030\000\000\002\016\0017\001\207\000\000\001\027\000\000\000\000\002\016\001\030\000\000\000\000\002\017\002$\002d\000\193\000\000\000\000\000\000\002\017\0017\002d\000\193\000\000\000\000\000\000\001'\001\030\000\000\001A\001#\0027\000\000\000\000\000\000\000\000\001'\000\000\002\016\001A\000\000\000\000\000\000\001\024\000\000\000\000\001\025\000\000\001#\002\017\000\000\002d\000\193\002e\001'\000\000\000\000\001A\000\000\001\t\000\000\002f\000\000\001}\002g\001\016\001\029\000\000\000\000\000\000\001\027\002e\000\000\000\000\000\000\000\000\000\000\001\t\002e\002f\000\000\001}\002g\001\016\001\029\000\000\002f\000\000\001}\002g\000\000\000\000\000\000\001\024\000\000\000\000\001\025\000\000\000\000\000\000\000\000\000\000\001\024\000\000\000\000\001\025\000\000\000\000\002e\000\000\0017\001\024\000\000\001#\001\025\000\000\002f\001\030\001}\002g\001\027\002\175\000\000\000\000\000\000\000\000\000\000\000\000\0017\001\027\000\000\002\r\002\014\001^\000\000\001\030\000\000\000\000\001\027\002\180\000\000\000\000\001\t\000\000\001'\000\000\000\000\001A\001\016\001\029\000\000\000\000\001\024\000\000\003\020\001\025\000\000\000\000\000\000\000\000\000\000\001\024\001'\001#\001\025\001A\000\000\000\000\000\000\000\000\000\000\000\000\001#\000\000\000\000\000\000\000\000\000\000\000\000\001\027\000\000\001#\000\000\000\000\000\000\000\000\000\000\000\000\001\027\000\000\000\000\000\000\001\t\0017\001\024\000\000\000\000\001\025\001\016\001\029\001\030\001\t\000\000\000\000\002\197\000\000\000\000\001\016\001\029\001\024\001\t\001\024\001\025\000\000\001\025\000\000\001\016\001\029\000\000\000\000\000\000\001\027\001#\000\000\000\000\000\000\002\016\001'\000\000\000\000\001A\001#\000\000\000\000\000\000\000\000\001\027\002\017\001\027\002d\000\193\000\000\000\000\0017\000\000\000\000\000\000\000\000\000\000\000\000\001\030\001\t\0017\000\000\002\204\000\000\000\000\001\016\001\029\001\030\001\t\0017\000\000\002\211\001#\000\000\001\016\001\029\001\030\000\000\001\024\000\000\002\220\001\025\000\000\000\000\000\000\001'\000\000\001#\001A\001#\000\000\000\000\000\000\000\000\001'\000\000\000\000\001A\000\000\000\000\000\000\001\t\000\000\001'\002e\001\027\001A\001\016\001\029\000\000\0017\000\000\002f\000\000\001}\002g\001\t\001\030\001\t\0017\000\000\004P\001\016\001\029\001\016\001\029\001\030\000\000\001\024\000\000\004\168\005\005\000\000\000\000\000\000\000\000\000\000\001\024\000\000\001\024\005\005\000\000\001\025\000\000\001'\000\000\000\000\001A\001#\000\000\000\000\000\000\0017\001'\001\024\001\027\001A\001\025\000\000\001\030\000\000\000\000\000\000\004\180\001\027\000\000\001\027\0017\000\000\0017\001\024\000\000\000\000\001\025\001\030\000\000\001\030\001\t\004\193\000\000\004\210\001\027\000\000\001\016\001\029\001\024\001'\001\024\001\025\001A\005\005\000\000\000\000\000\000\000\000\000\000\000\000\001\027\005\007\000\000\000\000\001'\000\000\001'\001A\000\000\001A\005\007\000\000\001#\000\000\000\000\001\027\000\000\001\027\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001#\000\000\000\000\001\t\0017\000\000\000\000\000\000\000\000\001\016\005\n\001\030\001\t\000\000\001\t\004\226\001#\000\000\001\016\005\n\001\016\001\029\001\024\000\000\000\000\005\005\000\000\000\000\000\000\001\t\000\000\001#\000\000\005\007\000\000\001\016\001\029\000\000\001'\000\000\000\000\001A\000\000\000\000\000\000\001\t\000\000\000\000\000\000\001\027\000\000\001\016\001\029\000\000\001\024\000\000\000\000\001\025\000\000\000\000\001\t\005\011\001\t\000\000\000\000\0017\001\016\001\029\001\016\005\n\005\011\001\024\001\030\004\213\001\025\005\012\005~\005\r\000\000\000\000\0017\001\027\004\213\000\000\005\024\000\000\005\r\001\030\001'\000\000\000\000\005\144\005\007\000\000\000\000\000\000\0017\001'\001\027\001'\000\000\000\000\001A\001\030\000\000\000\000\000\000\005\168\000\000\000\000\000\000\0017\000\000\001\024\001'\000\000\001\025\001A\001\030\000\000\005\011\001\t\0066\000\000\001#\000\000\000\000\001\016\005\n\000\000\001'\000\000\004\213\001A\005\228\000\000\005\r\000\000\000\000\000\000\001\027\001#\000\000\000\000\000\000\001'\001\024\001'\001A\001\025\000\000\000\000\000\000\001\t\001\024\000\000\000\000\001\025\000\000\001\016\001\029\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\t\000\000\000\000\001\027\000\000\000\000\001\016\001\029\000\000\005\011\000\000\001\027\000\000\001#\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\213\000\000\005\254\000\000\005\r\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0017\000\000\001'\000\000\000\000\000\000\000\000\001\030\001\t\000\000\000\000\006\139\001#\000\000\001\016\001\029\000\000\0017\000\000\000\000\001#\000\000\000\000\000\000\001\030\000\000\000\000\000\000\006\143\000\000\000\000\000\000\000\000\000\000\001'\000\000\000\000\001A\000\000\000\000\000\000\001\t\000\000\000\000\000\000\000\000\000\000\001\016\001\029\001\t\000\000\001'\000\000\000\000\001A\001\016\001\029\000\000\000\000\0017\000\000\000\000\000\000\000\000\000\000\000\000\001\030\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0017\001'\000\000\000\000\001\200\000\000\000\000\001\030\0017\000\000\000\000\000\000\000\000\000\000\000\000\001\030\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001'\000\000\000\000\001\202\000\000\000\000\000\000\000\000\001'\000\000\000\000\003\232"))
and semantic_action =
[|
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3579 "parsing/parser.mly"
+# 3641 "parsing/parser.mly"
( "+" )
-# 1315 "parsing/parser.ml"
+# 1338 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3580 "parsing/parser.mly"
+# 3642 "parsing/parser.mly"
( "+." )
-# 1340 "parsing/parser.ml"
+# 1363 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.core_type) =
-# 3148 "parsing/parser.mly"
+# 3198 "parsing/parser.mly"
( _1 )
-# 1365 "parsing/parser.ml"
+# 1388 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos_tyvar_ in
let _v : (Parsetree.core_type) = let _1 =
let _1 =
-# 3151 "parsing/parser.mly"
+# 3201 "parsing/parser.mly"
( Ptyp_alias(ty, tyvar) )
-# 1412 "parsing/parser.ml"
+# 1435 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_tyvar_, _startpos_ty_) in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 1421 "parsing/parser.ml"
+# 1444 "parsing/parser.ml"
in
-# 3153 "parsing/parser.mly"
+# 3203 "parsing/parser.mly"
( _1 )
-# 1427 "parsing/parser.ml"
+# 1450 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (let_binding) = let attrs2 =
let _1 = _1_inlined2 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 1475 "parsing/parser.ml"
+# 1498 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined2_ in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 1484 "parsing/parser.ml"
+# 1507 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2428 "parsing/parser.mly"
+# 2478 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
mklb ~loc:_sloc false body attrs
)
-# 1496 "parsing/parser.ml"
+# 1519 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ } = _menhir_stack in
+ let _1 : (Longident.t) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_ in
+ let _v : (Longident.t) =
+# 3528 "parsing/parser.mly"
+ ( _1 )
+# 1544 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ } = _menhir_stack in
+ let _1 : (Asttypes.label) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_ in
+ let _v : (Longident.t) =
+# 3529 "parsing/parser.mly"
+ ( Lident _1 )
+# 1569 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.core_type) =
-# 3209 "parsing/parser.mly"
+# 3259 "parsing/parser.mly"
( _2 )
-# 1535 "parsing/parser.ml"
+# 1608 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in
let _1 =
let _1 =
-# 3270 "parsing/parser.mly"
+# 3320 "parsing/parser.mly"
( Ptyp_package (package_type_of_module_type _1) )
-# 1598 "parsing/parser.ml"
+# 1671 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 1606 "parsing/parser.ml"
+# 1679 "parsing/parser.ml"
in
-# 3271 "parsing/parser.mly"
+# 3321 "parsing/parser.mly"
( _1 )
-# 1612 "parsing/parser.ml"
+# 1685 "parsing/parser.ml"
in
let _3 =
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 1622 "parsing/parser.ml"
+# 1695 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 1628 "parsing/parser.ml"
+# 1701 "parsing/parser.ml"
in
let _endpos = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3211 "parsing/parser.mly"
+# 3261 "parsing/parser.mly"
( wrap_typ_attrs ~loc:_sloc (reloc_typ ~loc:_sloc _4) _3 )
-# 1637 "parsing/parser.ml"
+# 1710 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__2_ in
let _v : (Parsetree.core_type) = let _1 =
let _1 =
-# 3214 "parsing/parser.mly"
+# 3264 "parsing/parser.mly"
( Ptyp_var _2 )
-# 1670 "parsing/parser.ml"
+# 1743 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 1679 "parsing/parser.ml"
+# 1752 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 1685 "parsing/parser.ml"
+# 1758 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.core_type) = let _1 =
let _1 =
-# 3216 "parsing/parser.mly"
+# 3266 "parsing/parser.mly"
( Ptyp_any )
-# 1711 "parsing/parser.ml"
+# 1784 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 1719 "parsing/parser.ml"
+# 1792 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 1725 "parsing/parser.ml"
+# 1798 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 1756 "parsing/parser.ml"
+# 1829 "parsing/parser.ml"
in
let tys =
-# 3261 "parsing/parser.mly"
+# 3311 "parsing/parser.mly"
( [] )
-# 1762 "parsing/parser.ml"
+# 1835 "parsing/parser.ml"
in
-# 3219 "parsing/parser.mly"
+# 3269 "parsing/parser.mly"
( Ptyp_constr(tid, tys) )
-# 1767 "parsing/parser.ml"
+# 1840 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 1776 "parsing/parser.ml"
+# 1849 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 1782 "parsing/parser.ml"
+# 1855 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 1820 "parsing/parser.ml"
+# 1893 "parsing/parser.ml"
in
let tys =
-# 3263 "parsing/parser.mly"
+# 3313 "parsing/parser.mly"
( [ty] )
-# 1826 "parsing/parser.ml"
+# 1899 "parsing/parser.ml"
in
-# 3219 "parsing/parser.mly"
+# 3269 "parsing/parser.mly"
( Ptyp_constr(tid, tys) )
-# 1831 "parsing/parser.ml"
+# 1904 "parsing/parser.ml"
in
let _startpos__1_ = _startpos_ty_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 1841 "parsing/parser.ml"
+# 1914 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 1847 "parsing/parser.ml"
+# 1920 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 1900 "parsing/parser.ml"
+# 1973 "parsing/parser.ml"
in
let tys =
let tys =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 1908 "parsing/parser.ml"
+# 1981 "parsing/parser.ml"
in
-# 954 "parsing/parser.mly"
+# 975 "parsing/parser.mly"
( xs )
-# 1913 "parsing/parser.ml"
+# 1986 "parsing/parser.ml"
in
-# 3265 "parsing/parser.mly"
+# 3315 "parsing/parser.mly"
( tys )
-# 1919 "parsing/parser.ml"
+# 1992 "parsing/parser.ml"
in
-# 3219 "parsing/parser.mly"
+# 3269 "parsing/parser.mly"
( Ptyp_constr(tid, tys) )
-# 1925 "parsing/parser.ml"
+# 1998 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 1935 "parsing/parser.ml"
+# 2008 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 1941 "parsing/parser.ml"
+# 2014 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__3_ in
let _v : (Parsetree.core_type) = let _1 =
let _1 =
-# 3221 "parsing/parser.mly"
+# 3271 "parsing/parser.mly"
( let (f, c) = _2 in Ptyp_object (f, c) )
-# 1981 "parsing/parser.ml"
+# 2054 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 1990 "parsing/parser.ml"
+# 2063 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 1996 "parsing/parser.ml"
+# 2069 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__2_ in
let _v : (Parsetree.core_type) = let _1 =
let _1 =
-# 3223 "parsing/parser.mly"
+# 3273 "parsing/parser.mly"
( Ptyp_object ([], Closed) )
-# 2029 "parsing/parser.ml"
+# 2102 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 2038 "parsing/parser.ml"
+# 2111 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 2044 "parsing/parser.ml"
+# 2117 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 2082 "parsing/parser.ml"
+# 2155 "parsing/parser.ml"
in
let tys =
-# 3261 "parsing/parser.mly"
+# 3311 "parsing/parser.mly"
( [] )
-# 2088 "parsing/parser.ml"
+# 2161 "parsing/parser.ml"
in
-# 3227 "parsing/parser.mly"
+# 3277 "parsing/parser.mly"
( Ptyp_class(cid, tys) )
-# 2093 "parsing/parser.ml"
+# 2166 "parsing/parser.ml"
in
let _startpos__1_ = _startpos__2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 2103 "parsing/parser.ml"
+# 2176 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 2109 "parsing/parser.ml"
+# 2182 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 2154 "parsing/parser.ml"
+# 2227 "parsing/parser.ml"
in
let tys =
-# 3263 "parsing/parser.mly"
+# 3313 "parsing/parser.mly"
( [ty] )
-# 2160 "parsing/parser.ml"
+# 2233 "parsing/parser.ml"
in
-# 3227 "parsing/parser.mly"
+# 3277 "parsing/parser.mly"
( Ptyp_class(cid, tys) )
-# 2165 "parsing/parser.ml"
+# 2238 "parsing/parser.ml"
in
let _startpos__1_ = _startpos_ty_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 2175 "parsing/parser.ml"
+# 2248 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 2181 "parsing/parser.ml"
+# 2254 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 2241 "parsing/parser.ml"
+# 2314 "parsing/parser.ml"
in
let tys =
let tys =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 2249 "parsing/parser.ml"
+# 2322 "parsing/parser.ml"
in
-# 954 "parsing/parser.mly"
+# 975 "parsing/parser.mly"
( xs )
-# 2254 "parsing/parser.ml"
+# 2327 "parsing/parser.ml"
in
-# 3265 "parsing/parser.mly"
+# 3315 "parsing/parser.mly"
( tys )
-# 2260 "parsing/parser.ml"
+# 2333 "parsing/parser.ml"
in
-# 3227 "parsing/parser.mly"
+# 3277 "parsing/parser.mly"
( Ptyp_class(cid, tys) )
-# 2266 "parsing/parser.ml"
+# 2339 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 2276 "parsing/parser.ml"
+# 2349 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 2282 "parsing/parser.ml"
+# 2355 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__3_ in
let _v : (Parsetree.core_type) = let _1 =
let _1 =
-# 3230 "parsing/parser.mly"
+# 3280 "parsing/parser.mly"
( Ptyp_variant([_2], Closed, None) )
-# 2322 "parsing/parser.ml"
+# 2395 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 2331 "parsing/parser.ml"
+# 2404 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 2337 "parsing/parser.ml"
+# 2410 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 =
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 2387 "parsing/parser.ml"
+# 2460 "parsing/parser.ml"
in
-# 926 "parsing/parser.mly"
+# 947 "parsing/parser.mly"
( xs )
-# 2392 "parsing/parser.ml"
+# 2465 "parsing/parser.ml"
in
-# 3275 "parsing/parser.mly"
+# 3325 "parsing/parser.mly"
( _1 )
-# 2398 "parsing/parser.ml"
+# 2471 "parsing/parser.ml"
in
-# 3232 "parsing/parser.mly"
+# 3282 "parsing/parser.mly"
( Ptyp_variant(_3, Closed, None) )
-# 2404 "parsing/parser.ml"
+# 2477 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 2414 "parsing/parser.ml"
+# 2487 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 2420 "parsing/parser.ml"
+# 2493 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _4 =
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 2477 "parsing/parser.ml"
+# 2550 "parsing/parser.ml"
in
-# 926 "parsing/parser.mly"
+# 947 "parsing/parser.mly"
( xs )
-# 2482 "parsing/parser.ml"
+# 2555 "parsing/parser.ml"
in
-# 3275 "parsing/parser.mly"
+# 3325 "parsing/parser.mly"
( _1 )
-# 2488 "parsing/parser.ml"
+# 2561 "parsing/parser.ml"
in
-# 3234 "parsing/parser.mly"
+# 3284 "parsing/parser.mly"
( Ptyp_variant(_2 :: _4, Closed, None) )
-# 2494 "parsing/parser.ml"
+# 2567 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 2504 "parsing/parser.ml"
+# 2577 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 2510 "parsing/parser.ml"
+# 2583 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 =
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 2560 "parsing/parser.ml"
+# 2633 "parsing/parser.ml"
in
-# 926 "parsing/parser.mly"
+# 947 "parsing/parser.mly"
( xs )
-# 2565 "parsing/parser.ml"
+# 2638 "parsing/parser.ml"
in
-# 3275 "parsing/parser.mly"
+# 3325 "parsing/parser.mly"
( _1 )
-# 2571 "parsing/parser.ml"
+# 2644 "parsing/parser.ml"
in
-# 3236 "parsing/parser.mly"
+# 3286 "parsing/parser.mly"
( Ptyp_variant(_3, Open, None) )
-# 2577 "parsing/parser.ml"
+# 2650 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 2587 "parsing/parser.ml"
+# 2660 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 2593 "parsing/parser.ml"
+# 2666 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__2_ in
let _v : (Parsetree.core_type) = let _1 =
let _1 =
-# 3238 "parsing/parser.mly"
+# 3288 "parsing/parser.mly"
( Ptyp_variant([], Open, None) )
-# 2626 "parsing/parser.ml"
+# 2699 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 2635 "parsing/parser.ml"
+# 2708 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 2641 "parsing/parser.ml"
+# 2714 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 =
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 2691 "parsing/parser.ml"
+# 2764 "parsing/parser.ml"
in
-# 926 "parsing/parser.mly"
+# 947 "parsing/parser.mly"
( xs )
-# 2696 "parsing/parser.ml"
+# 2769 "parsing/parser.ml"
in
-# 3275 "parsing/parser.mly"
+# 3325 "parsing/parser.mly"
( _1 )
-# 2702 "parsing/parser.ml"
+# 2775 "parsing/parser.ml"
in
-# 3240 "parsing/parser.mly"
+# 3290 "parsing/parser.mly"
( Ptyp_variant(_3, Closed, Some []) )
-# 2708 "parsing/parser.ml"
+# 2781 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 2718 "parsing/parser.ml"
+# 2791 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 2724 "parsing/parser.ml"
+# 2797 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let xs = xs_inlined1 in
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 2789 "parsing/parser.ml"
+# 2862 "parsing/parser.ml"
in
-# 894 "parsing/parser.mly"
+# 915 "parsing/parser.mly"
( xs )
-# 2794 "parsing/parser.ml"
+# 2867 "parsing/parser.ml"
in
-# 3303 "parsing/parser.mly"
+# 3353 "parsing/parser.mly"
( _1 )
-# 2800 "parsing/parser.ml"
+# 2873 "parsing/parser.ml"
in
let _3 =
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 2808 "parsing/parser.ml"
+# 2881 "parsing/parser.ml"
in
-# 926 "parsing/parser.mly"
+# 947 "parsing/parser.mly"
( xs )
-# 2813 "parsing/parser.ml"
+# 2886 "parsing/parser.ml"
in
-# 3275 "parsing/parser.mly"
+# 3325 "parsing/parser.mly"
( _1 )
-# 2819 "parsing/parser.ml"
+# 2892 "parsing/parser.ml"
in
-# 3242 "parsing/parser.mly"
+# 3292 "parsing/parser.mly"
( Ptyp_variant(_3, Closed, Some _5) )
-# 2825 "parsing/parser.ml"
+# 2898 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__6_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 2835 "parsing/parser.ml"
+# 2908 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 2841 "parsing/parser.ml"
+# 2914 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.core_type) = let _1 =
let _1 =
-# 3244 "parsing/parser.mly"
+# 3294 "parsing/parser.mly"
( Ptyp_extension _1 )
-# 2867 "parsing/parser.ml"
+# 2940 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 2875 "parsing/parser.ml"
+# 2948 "parsing/parser.ml"
in
-# 3246 "parsing/parser.mly"
+# 3296 "parsing/parser.mly"
( _1 )
-# 2881 "parsing/parser.ml"
+# 2954 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (string Asttypes.loc) = let _1 =
let _1 =
-# 3646 "parsing/parser.mly"
+# 3708 "parsing/parser.mly"
( _1 )
-# 2907 "parsing/parser.ml"
+# 2980 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 822 "parsing/parser.mly"
+# 843 "parsing/parser.mly"
( mkloc _1 (make_loc _sloc) )
-# 2915 "parsing/parser.ml"
+# 2988 "parsing/parser.ml"
in
-# 3648 "parsing/parser.mly"
+# 3710 "parsing/parser.mly"
( _1 )
-# 2921 "parsing/parser.ml"
+# 2994 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__3_ in
let _v : (string Asttypes.loc) = let _1 =
let _1 =
-# 3647 "parsing/parser.mly"
+# 3709 "parsing/parser.mly"
( _1 ^ "." ^ _3.txt )
-# 2961 "parsing/parser.ml"
+# 3034 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 822 "parsing/parser.mly"
+# 843 "parsing/parser.mly"
( mkloc _1 (make_loc _sloc) )
-# 2970 "parsing/parser.ml"
+# 3043 "parsing/parser.ml"
in
-# 3648 "parsing/parser.mly"
+# 3710 "parsing/parser.mly"
( _1 )
-# 2976 "parsing/parser.ml"
+# 3049 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3652 "parsing/parser.mly"
+# 3714 "parsing/parser.mly"
( Attr.mk ~loc:(make_loc _sloc) _2 _3 )
-# 3025 "parsing/parser.ml"
+# 3098 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.class_expr) =
-# 1712 "parsing/parser.mly"
+# 1762 "parsing/parser.mly"
( _1 )
-# 3050 "parsing/parser.ml"
+# 3123 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.class_expr) = let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 3091 "parsing/parser.ml"
+# 3164 "parsing/parser.ml"
in
let _endpos = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1714 "parsing/parser.mly"
+# 1764 "parsing/parser.mly"
( wrap_class_attrs ~loc:_sloc _3 _2 )
-# 3100 "parsing/parser.ml"
+# 3173 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1716 "parsing/parser.mly"
+# 1766 "parsing/parser.mly"
( class_of_let_bindings ~loc:_sloc _1 _3 )
-# 3142 "parsing/parser.ml"
+# 3215 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 3207 "parsing/parser.ml"
+# 3280 "parsing/parser.ml"
in
let _4 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 3215 "parsing/parser.ml"
+# 3288 "parsing/parser.ml"
in
let _endpos__4_ = _endpos__1_inlined1_ in
let _3 =
-# 3571 "parsing/parser.mly"
+# 3633 "parsing/parser.mly"
( Fresh )
-# 3222 "parsing/parser.ml"
+# 3295 "parsing/parser.ml"
in
let _endpos = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1718 "parsing/parser.mly"
+# 1768 "parsing/parser.mly"
( let loc = (_startpos__2_, _endpos__4_) in
let od = Opn.mk ~override:_3 ~loc:(make_loc loc) _5 in
mkclass ~loc:_sloc ~attrs:_4 (Pcl_open(od, _7)) )
-# 3232 "parsing/parser.ml"
+# 3305 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 3304 "parsing/parser.ml"
+# 3377 "parsing/parser.ml"
in
let _4 =
let _1 = _1_inlined2 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 3312 "parsing/parser.ml"
+# 3385 "parsing/parser.ml"
in
let _endpos__4_ = _endpos__1_inlined2_ in
let _3 =
let _1 = _1_inlined1 in
-# 3572 "parsing/parser.mly"
+# 3634 "parsing/parser.mly"
( Override )
-# 3321 "parsing/parser.ml"
+# 3394 "parsing/parser.ml"
in
let _endpos = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1718 "parsing/parser.mly"
+# 1768 "parsing/parser.mly"
( let loc = (_startpos__2_, _endpos__4_) in
let od = Opn.mk ~override:_3 ~loc:(make_loc loc) _5 in
mkclass ~loc:_sloc ~attrs:_4 (Pcl_open(od, _7)) )
-# 3332 "parsing/parser.ml"
+# 3405 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.class_expr) =
-# 1722 "parsing/parser.mly"
+# 1772 "parsing/parser.mly"
( Cl.attr _1 _2 )
-# 3364 "parsing/parser.ml"
+# 3437 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _2 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 3399 "parsing/parser.ml"
+# 3472 "parsing/parser.ml"
in
-# 894 "parsing/parser.mly"
+# 915 "parsing/parser.mly"
( xs )
-# 3404 "parsing/parser.ml"
+# 3477 "parsing/parser.ml"
in
-# 1725 "parsing/parser.mly"
+# 1775 "parsing/parser.mly"
( Pcl_apply(_1, _2) )
-# 3410 "parsing/parser.ml"
+# 3483 "parsing/parser.ml"
in
let _endpos__1_ = _endpos_xs_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 845 "parsing/parser.mly"
+# 866 "parsing/parser.mly"
( mkclass ~loc:_sloc _1 )
-# 3420 "parsing/parser.ml"
+# 3493 "parsing/parser.ml"
in
-# 1728 "parsing/parser.mly"
+# 1778 "parsing/parser.mly"
( _1 )
-# 3426 "parsing/parser.ml"
+# 3499 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.class_expr) = let _1 =
let _1 =
-# 1727 "parsing/parser.mly"
+# 1777 "parsing/parser.mly"
( Pcl_extension _1 )
-# 3452 "parsing/parser.ml"
+# 3525 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 845 "parsing/parser.mly"
+# 866 "parsing/parser.mly"
( mkclass ~loc:_sloc _1 )
-# 3460 "parsing/parser.ml"
+# 3533 "parsing/parser.ml"
in
-# 1728 "parsing/parser.mly"
+# 1778 "parsing/parser.mly"
( _1 )
-# 3466 "parsing/parser.ml"
+# 3539 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.class_field) = let _6 =
let _1 = _1_inlined2 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 3521 "parsing/parser.ml"
+# 3594 "parsing/parser.ml"
in
let _endpos__6_ = _endpos__1_inlined2_ in
let _3 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 3530 "parsing/parser.ml"
+# 3603 "parsing/parser.ml"
in
let _2 =
-# 3571 "parsing/parser.mly"
+# 3633 "parsing/parser.mly"
( Fresh )
-# 3536 "parsing/parser.ml"
+# 3609 "parsing/parser.ml"
in
let _endpos = _endpos__6_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1777 "parsing/parser.mly"
+# 1827 "parsing/parser.mly"
( let docs = symbol_docs _sloc in
mkcf ~loc:_sloc (Pcf_inherit (_2, _4, self)) ~attrs:(_3@_6) ~docs )
-# 3545 "parsing/parser.ml"
+# 3618 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.class_field) = let _6 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 3607 "parsing/parser.ml"
+# 3680 "parsing/parser.ml"
in
let _endpos__6_ = _endpos__1_inlined3_ in
let _3 =
let _1 = _1_inlined2 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 3616 "parsing/parser.ml"
+# 3689 "parsing/parser.ml"
in
let _2 =
let _1 = _1_inlined1 in
-# 3572 "parsing/parser.mly"
+# 3634 "parsing/parser.mly"
( Override )
-# 3624 "parsing/parser.ml"
+# 3697 "parsing/parser.ml"
in
let _endpos = _endpos__6_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1777 "parsing/parser.mly"
+# 1827 "parsing/parser.mly"
( let docs = symbol_docs _sloc in
mkcf ~loc:_sloc (Pcf_inherit (_2, _4, self)) ~attrs:(_3@_6) ~docs )
-# 3634 "parsing/parser.ml"
+# 3707 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.class_field) = let _3 =
let _1 = _1_inlined1 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 3677 "parsing/parser.ml"
+# 3750 "parsing/parser.ml"
in
let _endpos__3_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1780 "parsing/parser.mly"
+# 1830 "parsing/parser.mly"
( let v, attrs = _2 in
let docs = symbol_docs _sloc in
mkcf ~loc:_sloc (Pcf_val v) ~attrs:(attrs@_3) ~docs )
-# 3689 "parsing/parser.ml"
+# 3762 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.class_field) = let _3 =
let _1 = _1_inlined1 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 3732 "parsing/parser.ml"
+# 3805 "parsing/parser.ml"
in
let _endpos__3_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1784 "parsing/parser.mly"
+# 1834 "parsing/parser.mly"
( let meth, attrs = _2 in
let docs = symbol_docs _sloc in
mkcf ~loc:_sloc (Pcf_method meth) ~attrs:(attrs@_3) ~docs )
-# 3744 "parsing/parser.ml"
+# 3817 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.class_field) = let _4 =
let _1 = _1_inlined2 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 3792 "parsing/parser.ml"
+# 3865 "parsing/parser.ml"
in
let _endpos__4_ = _endpos__1_inlined2_ in
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 3801 "parsing/parser.ml"
+# 3874 "parsing/parser.ml"
in
let _endpos = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1788 "parsing/parser.mly"
+# 1838 "parsing/parser.mly"
( let docs = symbol_docs _sloc in
mkcf ~loc:_sloc (Pcf_constraint _3) ~attrs:(_2@_4) ~docs )
-# 3811 "parsing/parser.ml"
+# 3884 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.class_field) = let _4 =
let _1 = _1_inlined2 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 3859 "parsing/parser.ml"
+# 3932 "parsing/parser.ml"
in
let _endpos__4_ = _endpos__1_inlined2_ in
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 3868 "parsing/parser.ml"
+# 3941 "parsing/parser.ml"
in
let _endpos = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1791 "parsing/parser.mly"
+# 1841 "parsing/parser.mly"
( let docs = symbol_docs _sloc in
mkcf ~loc:_sloc (Pcf_initializer _3) ~attrs:(_2@_4) ~docs )
-# 3878 "parsing/parser.ml"
+# 3951 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.class_field) = let _2 =
let _1 = _1_inlined1 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 3912 "parsing/parser.ml"
+# 3985 "parsing/parser.ml"
in
let _endpos__2_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1794 "parsing/parser.mly"
+# 1844 "parsing/parser.mly"
( let docs = symbol_docs _sloc in
mkcf ~loc:_sloc (Pcf_extension _1) ~attrs:_2 ~docs )
-# 3923 "parsing/parser.ml"
+# 3996 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.class_field) = let _1 =
let _1 =
-# 1797 "parsing/parser.mly"
+# 1847 "parsing/parser.mly"
( Pcf_attribute _1 )
-# 3949 "parsing/parser.ml"
+# 4022 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 843 "parsing/parser.mly"
+# 864 "parsing/parser.mly"
( mkcf ~loc:_sloc _1 )
-# 3957 "parsing/parser.ml"
+# 4030 "parsing/parser.ml"
in
-# 1798 "parsing/parser.mly"
+# 1848 "parsing/parser.mly"
( _1 )
-# 3963 "parsing/parser.ml"
+# 4036 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.class_expr) =
-# 1692 "parsing/parser.mly"
+# 1742 "parsing/parser.mly"
( _2 )
-# 3995 "parsing/parser.ml"
+# 4068 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__4_ in
let _v : (Parsetree.class_expr) = let _1 =
let _1 =
-# 1695 "parsing/parser.mly"
+# 1745 "parsing/parser.mly"
( Pcl_constraint(_4, _2) )
-# 4042 "parsing/parser.ml"
+# 4115 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__4_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 845 "parsing/parser.mly"
+# 866 "parsing/parser.mly"
( mkclass ~loc:_sloc _1 )
-# 4051 "parsing/parser.ml"
+# 4124 "parsing/parser.ml"
in
-# 1698 "parsing/parser.mly"
+# 1748 "parsing/parser.mly"
( _1 )
-# 4057 "parsing/parser.ml"
+# 4130 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__2_ in
let _v : (Parsetree.class_expr) = let _1 =
let _1 =
-# 1697 "parsing/parser.mly"
+# 1747 "parsing/parser.mly"
( let (l,o,p) = _1 in Pcl_fun(l, o, p, _2) )
-# 4090 "parsing/parser.ml"
+# 4163 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 845 "parsing/parser.mly"
+# 866 "parsing/parser.mly"
( mkclass ~loc:_sloc _1 )
-# 4099 "parsing/parser.ml"
+# 4172 "parsing/parser.ml"
in
-# 1698 "parsing/parser.mly"
+# 1748 "parsing/parser.mly"
( _1 )
-# 4105 "parsing/parser.ml"
+# 4178 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos_e_ in
let _v : (Parsetree.class_expr) = let _1 =
let _1 =
-# 1753 "parsing/parser.mly"
+# 1803 "parsing/parser.mly"
( let (l,o,p) = _1 in Pcl_fun(l, o, p, e) )
-# 4145 "parsing/parser.ml"
+# 4218 "parsing/parser.ml"
in
let _endpos__1_ = _endpos_e_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 845 "parsing/parser.mly"
+# 866 "parsing/parser.mly"
( mkclass ~loc:_sloc _1 )
-# 4154 "parsing/parser.ml"
+# 4227 "parsing/parser.ml"
in
-# 1754 "parsing/parser.mly"
+# 1804 "parsing/parser.mly"
( _1 )
-# 4160 "parsing/parser.ml"
+# 4233 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos_e_ in
let _v : (Parsetree.class_expr) = let _1 =
let _1 =
-# 1753 "parsing/parser.mly"
+# 1803 "parsing/parser.mly"
( let (l,o,p) = _1 in Pcl_fun(l, o, p, e) )
-# 4193 "parsing/parser.ml"
+# 4266 "parsing/parser.ml"
in
let _endpos__1_ = _endpos_e_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 845 "parsing/parser.mly"
+# 866 "parsing/parser.mly"
( mkclass ~loc:_sloc _1 )
-# 4202 "parsing/parser.ml"
+# 4275 "parsing/parser.ml"
in
-# 1754 "parsing/parser.mly"
+# 1804 "parsing/parser.mly"
( _1 )
-# 4208 "parsing/parser.ml"
+# 4281 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.endp = _endpos__1_;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
- let _1 : (
-# 642 "parsing/parser.mly"
- (string)
-# 4229 "parsing/parser.ml"
- ) = Obj.magic _1 in
- let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
- let _startpos = _startpos__1_ in
- let _endpos = _endpos__1_ in
- let _v : (Longident.t) =
-# 3466 "parsing/parser.mly"
- ( Lident _1 )
-# 4237 "parsing/parser.ml"
- in
- {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = Obj.repr _v;
- MenhirLib.EngineTypes.startp = _startpos;
- MenhirLib.EngineTypes.endp = _endpos;
- MenhirLib.EngineTypes.next = _menhir_stack;
- });
- (fun _menhir_env ->
- let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
- let {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _3;
- MenhirLib.EngineTypes.startp = _startpos__3_;
- MenhirLib.EngineTypes.endp = _endpos__3_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _2;
- MenhirLib.EngineTypes.startp = _startpos__2_;
- MenhirLib.EngineTypes.endp = _endpos__2_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = _1;
- MenhirLib.EngineTypes.startp = _startpos__1_;
- MenhirLib.EngineTypes.endp = _endpos__1_;
- MenhirLib.EngineTypes.next = _menhir_stack;
- };
- };
- } = _menhir_stack in
- let _3 : (
-# 642 "parsing/parser.mly"
- (string)
-# 4270 "parsing/parser.ml"
- ) = Obj.magic _3 in
- let _2 : unit = Obj.magic _2 in
let _1 : (Longident.t) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
- let _endpos = _endpos__3_ in
+ let _endpos = _endpos__1_ in
let _v : (Longident.t) =
-# 3467 "parsing/parser.mly"
- ( Ldot(_1, _3) )
-# 4280 "parsing/parser.ml"
+# 3519 "parsing/parser.mly"
+ ( _1 )
+# 4306 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1762 "parsing/parser.mly"
+# 1812 "parsing/parser.mly"
( reloc_pat ~loc:_sloc _2 )
-# 4322 "parsing/parser.ml"
+# 4348 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : (Parsetree.pattern) = let _1 =
let _1 =
-# 1764 "parsing/parser.mly"
+# 1814 "parsing/parser.mly"
( Ppat_constraint(_2, _4) )
-# 4376 "parsing/parser.ml"
+# 4402 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 4385 "parsing/parser.ml"
+# 4411 "parsing/parser.ml"
in
-# 1765 "parsing/parser.mly"
+# 1815 "parsing/parser.mly"
( _1 )
-# 4391 "parsing/parser.ml"
+# 4417 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _endpos in
let _sloc = (_symbolstartpos, _endpos) in
-# 1767 "parsing/parser.mly"
+# 1817 "parsing/parser.mly"
( ghpat ~loc:_sloc Ppat_any )
-# 4412 "parsing/parser.ml"
+# 4438 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.core_type) =
-# 1892 "parsing/parser.mly"
+# 1942 "parsing/parser.mly"
( _2 )
-# 4451 "parsing/parser.ml"
+# 4477 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _startpos in
let _v : (Parsetree.core_type) = let _1 =
let _1 =
-# 1893 "parsing/parser.mly"
+# 1943 "parsing/parser.mly"
( Ptyp_any )
-# 4470 "parsing/parser.ml"
+# 4496 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__0_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _endpos in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 4479 "parsing/parser.ml"
+# 4505 "parsing/parser.ml"
in
-# 1894 "parsing/parser.mly"
+# 1944 "parsing/parser.mly"
( _1 )
-# 4485 "parsing/parser.ml"
+# 4511 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.class_type_field) = let _4 =
let _1 = _1_inlined2 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 4533 "parsing/parser.ml"
+# 4559 "parsing/parser.ml"
in
let _endpos__4_ = _endpos__1_inlined2_ in
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 4542 "parsing/parser.ml"
+# 4568 "parsing/parser.ml"
in
let _endpos = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1902 "parsing/parser.mly"
+# 1952 "parsing/parser.mly"
( let docs = symbol_docs _sloc in
mkctf ~loc:_sloc (Pctf_inherit _3) ~attrs:(_2@_4) ~docs )
-# 4552 "parsing/parser.ml"
+# 4578 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let ty : (Parsetree.core_type) = Obj.magic ty in
let _3 : unit = Obj.magic _3 in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 4612 "parsing/parser.ml"
+# 4638 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let flags : (Asttypes.mutable_flag * Asttypes.virtual_flag) = Obj.magic flags in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
let _v : (Parsetree.class_type_field) = let _4 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 4625 "parsing/parser.ml"
+# 4651 "parsing/parser.ml"
in
let _endpos__4_ = _endpos__1_inlined3_ in
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in
let label =
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 4635 "parsing/parser.ml"
+# 4661 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 4643 "parsing/parser.ml"
+# 4669 "parsing/parser.ml"
in
-# 1927 "parsing/parser.mly"
+# 1977 "parsing/parser.mly"
(
let mut, virt = flags in
label, mut, virt, ty
)
-# 4652 "parsing/parser.ml"
+# 4678 "parsing/parser.ml"
in
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 4660 "parsing/parser.ml"
+# 4686 "parsing/parser.ml"
in
let _endpos = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1905 "parsing/parser.mly"
+# 1955 "parsing/parser.mly"
( let docs = symbol_docs _sloc in
mkctf ~loc:_sloc (Pctf_val _3) ~attrs:(_2@_4) ~docs )
-# 4670 "parsing/parser.ml"
+# 4696 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined3 : (Parsetree.core_type) = Obj.magic _1_inlined3 in
let _5 : unit = Obj.magic _5 in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 4730 "parsing/parser.ml"
+# 4756 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let _3 : (Asttypes.private_flag * Asttypes.virtual_flag) = Obj.magic _3 in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
let _v : (Parsetree.class_type_field) = let _7 =
let _1 = _1_inlined4 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 4743 "parsing/parser.ml"
+# 4769 "parsing/parser.ml"
in
let _endpos__7_ = _endpos__1_inlined4_ in
let _6 =
let _1 = _1_inlined3 in
-# 3114 "parsing/parser.mly"
+# 3164 "parsing/parser.mly"
( _1 )
-# 4752 "parsing/parser.ml"
+# 4778 "parsing/parser.ml"
in
let _4 =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 4760 "parsing/parser.ml"
+# 4786 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 4768 "parsing/parser.ml"
+# 4794 "parsing/parser.ml"
in
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 4776 "parsing/parser.ml"
+# 4802 "parsing/parser.ml"
in
let _endpos = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1909 "parsing/parser.mly"
+# 1959 "parsing/parser.mly"
( let (p, v) = _3 in
let docs = symbol_docs _sloc in
mkctf ~loc:_sloc (Pctf_method (_4, p, v, _6)) ~attrs:(_2@_7) ~docs )
-# 4787 "parsing/parser.ml"
+# 4813 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.class_type_field) = let _4 =
let _1 = _1_inlined2 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 4835 "parsing/parser.ml"
+# 4861 "parsing/parser.ml"
in
let _endpos__4_ = _endpos__1_inlined2_ in
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 4844 "parsing/parser.ml"
+# 4870 "parsing/parser.ml"
in
let _endpos = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1913 "parsing/parser.mly"
+# 1963 "parsing/parser.mly"
( let docs = symbol_docs _sloc in
mkctf ~loc:_sloc (Pctf_constraint _3) ~attrs:(_2@_4) ~docs )
-# 4854 "parsing/parser.ml"
+# 4880 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.class_type_field) = let _2 =
let _1 = _1_inlined1 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 4888 "parsing/parser.ml"
+# 4914 "parsing/parser.ml"
in
let _endpos__2_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1916 "parsing/parser.mly"
+# 1966 "parsing/parser.mly"
( let docs = symbol_docs _sloc in
mkctf ~loc:_sloc (Pctf_extension _1) ~attrs:_2 ~docs )
-# 4899 "parsing/parser.ml"
+# 4925 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.class_type_field) = let _1 =
let _1 =
-# 1919 "parsing/parser.mly"
+# 1969 "parsing/parser.mly"
( Pctf_attribute _1 )
-# 4925 "parsing/parser.ml"
+# 4951 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 841 "parsing/parser.mly"
+# 862 "parsing/parser.mly"
( mkctf ~loc:_sloc _1 )
-# 4933 "parsing/parser.ml"
+# 4959 "parsing/parser.ml"
in
-# 1920 "parsing/parser.mly"
+# 1970 "parsing/parser.mly"
( _1 )
-# 4939 "parsing/parser.ml"
+# 4965 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 4970 "parsing/parser.ml"
+# 4996 "parsing/parser.ml"
in
let tys =
let tys =
-# 1878 "parsing/parser.mly"
+# 1928 "parsing/parser.mly"
( [] )
-# 4977 "parsing/parser.ml"
+# 5003 "parsing/parser.ml"
in
-# 1884 "parsing/parser.mly"
+# 1934 "parsing/parser.mly"
( tys )
-# 4982 "parsing/parser.ml"
+# 5008 "parsing/parser.ml"
in
-# 1861 "parsing/parser.mly"
+# 1911 "parsing/parser.mly"
( Pcty_constr (cid, tys) )
-# 4988 "parsing/parser.ml"
+# 5014 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 839 "parsing/parser.mly"
+# 860 "parsing/parser.mly"
( mkcty ~loc:_sloc _1 )
-# 4997 "parsing/parser.ml"
+# 5023 "parsing/parser.ml"
in
-# 1864 "parsing/parser.mly"
+# 1914 "parsing/parser.mly"
( _1 )
-# 5003 "parsing/parser.ml"
+# 5029 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 5056 "parsing/parser.ml"
+# 5082 "parsing/parser.ml"
in
let tys =
let tys =
let params =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 5065 "parsing/parser.ml"
+# 5091 "parsing/parser.ml"
in
-# 926 "parsing/parser.mly"
+# 947 "parsing/parser.mly"
( xs )
-# 5070 "parsing/parser.ml"
+# 5096 "parsing/parser.ml"
in
-# 1880 "parsing/parser.mly"
+# 1930 "parsing/parser.mly"
( params )
-# 5076 "parsing/parser.ml"
+# 5102 "parsing/parser.ml"
in
-# 1884 "parsing/parser.mly"
+# 1934 "parsing/parser.mly"
( tys )
-# 5082 "parsing/parser.ml"
+# 5108 "parsing/parser.ml"
in
-# 1861 "parsing/parser.mly"
+# 1911 "parsing/parser.mly"
( Pcty_constr (cid, tys) )
-# 5088 "parsing/parser.ml"
+# 5114 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 839 "parsing/parser.mly"
+# 860 "parsing/parser.mly"
( mkcty ~loc:_sloc _1 )
-# 5098 "parsing/parser.ml"
+# 5124 "parsing/parser.ml"
in
-# 1864 "parsing/parser.mly"
+# 1914 "parsing/parser.mly"
( _1 )
-# 5104 "parsing/parser.ml"
+# 5130 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.class_type) = let _1 =
let _1 =
-# 1863 "parsing/parser.mly"
+# 1913 "parsing/parser.mly"
( Pcty_extension _1 )
-# 5130 "parsing/parser.ml"
+# 5156 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 839 "parsing/parser.mly"
+# 860 "parsing/parser.mly"
( mkcty ~loc:_sloc _1 )
-# 5138 "parsing/parser.ml"
+# 5164 "parsing/parser.ml"
in
-# 1864 "parsing/parser.mly"
+# 1914 "parsing/parser.mly"
( _1 )
-# 5144 "parsing/parser.ml"
+# 5170 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 =
let _1 =
-# 260 "menhir/standard.mly"
+# 260 "<standard.mly>"
( List.flatten xss )
-# 5201 "parsing/parser.ml"
+# 5227 "parsing/parser.ml"
in
-# 1898 "parsing/parser.mly"
+# 1948 "parsing/parser.mly"
( _1 )
-# 5206 "parsing/parser.ml"
+# 5232 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in
let _endpos = _endpos__1_ in
let _startpos = _startpos__1_ in
-# 787 "parsing/parser.mly"
+# 808 "parsing/parser.mly"
( extra_csig _startpos _endpos _1 )
-# 5215 "parsing/parser.ml"
+# 5241 "parsing/parser.ml"
in
-# 1888 "parsing/parser.mly"
+# 1938 "parsing/parser.mly"
( Csig.mk _1 _2 )
-# 5221 "parsing/parser.ml"
+# 5247 "parsing/parser.ml"
in
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 5229 "parsing/parser.ml"
+# 5255 "parsing/parser.ml"
in
let _endpos = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1866 "parsing/parser.mly"
+# 1916 "parsing/parser.mly"
( mkcty ~loc:_sloc ~attrs:_2 (Pcty_signature _3) )
-# 5238 "parsing/parser.ml"
+# 5264 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 =
let _1 =
-# 260 "menhir/standard.mly"
+# 260 "<standard.mly>"
( List.flatten xss )
-# 5295 "parsing/parser.ml"
+# 5321 "parsing/parser.ml"
in
-# 1898 "parsing/parser.mly"
+# 1948 "parsing/parser.mly"
( _1 )
-# 5300 "parsing/parser.ml"
+# 5326 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in
let _endpos = _endpos__1_ in
let _startpos = _startpos__1_ in
-# 787 "parsing/parser.mly"
+# 808 "parsing/parser.mly"
( extra_csig _startpos _endpos _1 )
-# 5309 "parsing/parser.ml"
+# 5335 "parsing/parser.ml"
in
-# 1888 "parsing/parser.mly"
+# 1938 "parsing/parser.mly"
( Csig.mk _1 _2 )
-# 5315 "parsing/parser.ml"
+# 5341 "parsing/parser.ml"
in
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 5323 "parsing/parser.ml"
+# 5349 "parsing/parser.ml"
in
let _loc__4_ = (_startpos__4_, _endpos__4_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1868 "parsing/parser.mly"
+# 1918 "parsing/parser.mly"
( unclosed "object" _loc__1_ "end" _loc__4_ )
-# 5331 "parsing/parser.ml"
+# 5357 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.class_type) =
-# 1870 "parsing/parser.mly"
+# 1920 "parsing/parser.mly"
( Cty.attr _1 _2 )
-# 5363 "parsing/parser.ml"
+# 5389 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 5428 "parsing/parser.ml"
+# 5454 "parsing/parser.ml"
in
let _4 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 5436 "parsing/parser.ml"
+# 5462 "parsing/parser.ml"
in
let _endpos__4_ = _endpos__1_inlined1_ in
let _3 =
-# 3571 "parsing/parser.mly"
+# 3633 "parsing/parser.mly"
( Fresh )
-# 5443 "parsing/parser.ml"
+# 5469 "parsing/parser.ml"
in
let _endpos = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1872 "parsing/parser.mly"
+# 1922 "parsing/parser.mly"
( let loc = (_startpos__2_, _endpos__4_) in
let od = Opn.mk ~override:_3 ~loc:(make_loc loc) _5 in
mkcty ~loc:_sloc ~attrs:_4 (Pcty_open(od, _7)) )
-# 5453 "parsing/parser.ml"
+# 5479 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 5525 "parsing/parser.ml"
+# 5551 "parsing/parser.ml"
in
let _4 =
let _1 = _1_inlined2 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 5533 "parsing/parser.ml"
+# 5559 "parsing/parser.ml"
in
let _endpos__4_ = _endpos__1_inlined2_ in
let _3 =
let _1 = _1_inlined1 in
-# 3572 "parsing/parser.mly"
+# 3634 "parsing/parser.mly"
( Override )
-# 5542 "parsing/parser.ml"
+# 5568 "parsing/parser.ml"
in
let _endpos = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1872 "parsing/parser.mly"
+# 1922 "parsing/parser.mly"
( let loc = (_startpos__2_, _endpos__4_) in
let od = Opn.mk ~override:_3 ~loc:(make_loc loc) _5 in
mkcty ~loc:_sloc ~attrs:_4 (Pcty_open(od, _7)) )
-# 5553 "parsing/parser.ml"
+# 5579 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.class_expr) =
-# 1732 "parsing/parser.mly"
+# 1782 "parsing/parser.mly"
( _2 )
-# 5592 "parsing/parser.ml"
+# 5618 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.class_expr) = let _loc__3_ = (_startpos__3_, _endpos__3_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1734 "parsing/parser.mly"
+# 1784 "parsing/parser.mly"
( unclosed "(" _loc__1_ ")" _loc__3_ )
-# 5633 "parsing/parser.ml"
+# 5659 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 5664 "parsing/parser.ml"
+# 5690 "parsing/parser.ml"
in
let tys =
let tys =
-# 1878 "parsing/parser.mly"
+# 1928 "parsing/parser.mly"
( [] )
-# 5671 "parsing/parser.ml"
+# 5697 "parsing/parser.ml"
in
-# 1884 "parsing/parser.mly"
+# 1934 "parsing/parser.mly"
( tys )
-# 5676 "parsing/parser.ml"
+# 5702 "parsing/parser.ml"
in
-# 1737 "parsing/parser.mly"
+# 1787 "parsing/parser.mly"
( Pcl_constr(cid, tys) )
-# 5682 "parsing/parser.ml"
+# 5708 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 845 "parsing/parser.mly"
+# 866 "parsing/parser.mly"
( mkclass ~loc:_sloc _1 )
-# 5691 "parsing/parser.ml"
+# 5717 "parsing/parser.ml"
in
-# 1744 "parsing/parser.mly"
+# 1794 "parsing/parser.mly"
( _1 )
-# 5697 "parsing/parser.ml"
+# 5723 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 5750 "parsing/parser.ml"
+# 5776 "parsing/parser.ml"
in
let tys =
let tys =
let params =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 5759 "parsing/parser.ml"
+# 5785 "parsing/parser.ml"
in
-# 926 "parsing/parser.mly"
+# 947 "parsing/parser.mly"
( xs )
-# 5764 "parsing/parser.ml"
+# 5790 "parsing/parser.ml"
in
-# 1880 "parsing/parser.mly"
+# 1930 "parsing/parser.mly"
( params )
-# 5770 "parsing/parser.ml"
+# 5796 "parsing/parser.ml"
in
-# 1884 "parsing/parser.mly"
+# 1934 "parsing/parser.mly"
( tys )
-# 5776 "parsing/parser.ml"
+# 5802 "parsing/parser.ml"
in
-# 1737 "parsing/parser.mly"
+# 1787 "parsing/parser.mly"
( Pcl_constr(cid, tys) )
-# 5782 "parsing/parser.ml"
+# 5808 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 845 "parsing/parser.mly"
+# 866 "parsing/parser.mly"
( mkclass ~loc:_sloc _1 )
-# 5792 "parsing/parser.ml"
+# 5818 "parsing/parser.ml"
in
-# 1744 "parsing/parser.mly"
+# 1794 "parsing/parser.mly"
( _1 )
-# 5798 "parsing/parser.ml"
+# 5824 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 =
let _1 =
-# 260 "menhir/standard.mly"
+# 260 "<standard.mly>"
( List.flatten xss )
-# 5857 "parsing/parser.ml"
+# 5883 "parsing/parser.ml"
in
-# 1771 "parsing/parser.mly"
+# 1821 "parsing/parser.mly"
( _1 )
-# 5862 "parsing/parser.ml"
+# 5888 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in
let _endpos = _endpos__1_ in
let _startpos = _startpos__1_ in
-# 786 "parsing/parser.mly"
+# 807 "parsing/parser.mly"
( extra_cstr _startpos _endpos _1 )
-# 5871 "parsing/parser.ml"
+# 5897 "parsing/parser.ml"
in
-# 1758 "parsing/parser.mly"
+# 1808 "parsing/parser.mly"
( Cstr.mk _1 _2 )
-# 5877 "parsing/parser.ml"
+# 5903 "parsing/parser.ml"
in
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 5885 "parsing/parser.ml"
+# 5911 "parsing/parser.ml"
in
let _loc__4_ = (_startpos__4_, _endpos__4_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1739 "parsing/parser.mly"
+# 1789 "parsing/parser.mly"
( unclosed "object" _loc__1_ "end" _loc__4_ )
-# 5893 "parsing/parser.ml"
+# 5919 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 845 "parsing/parser.mly"
+# 866 "parsing/parser.mly"
( mkclass ~loc:_sloc _1 )
-# 5903 "parsing/parser.ml"
+# 5929 "parsing/parser.ml"
in
-# 1744 "parsing/parser.mly"
+# 1794 "parsing/parser.mly"
( _1 )
-# 5909 "parsing/parser.ml"
+# 5935 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : (Parsetree.class_expr) = let _1 =
let _1 =
-# 1741 "parsing/parser.mly"
+# 1791 "parsing/parser.mly"
( Pcl_constraint(_2, _4) )
-# 5963 "parsing/parser.ml"
+# 5989 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 845 "parsing/parser.mly"
+# 866 "parsing/parser.mly"
( mkclass ~loc:_sloc _1 )
-# 5972 "parsing/parser.ml"
+# 5998 "parsing/parser.ml"
in
-# 1744 "parsing/parser.mly"
+# 1794 "parsing/parser.mly"
( _1 )
-# 5978 "parsing/parser.ml"
+# 6004 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1743 "parsing/parser.mly"
+# 1793 "parsing/parser.mly"
( unclosed "(" _loc__1_ ")" _loc__5_ )
-# 6035 "parsing/parser.ml"
+# 6061 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 845 "parsing/parser.mly"
+# 866 "parsing/parser.mly"
( mkclass ~loc:_sloc _1 )
-# 6045 "parsing/parser.ml"
+# 6071 "parsing/parser.ml"
in
-# 1744 "parsing/parser.mly"
+# 1794 "parsing/parser.mly"
( _1 )
-# 6051 "parsing/parser.ml"
+# 6077 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 =
let _1 =
-# 260 "menhir/standard.mly"
+# 260 "<standard.mly>"
( List.flatten xss )
-# 6108 "parsing/parser.ml"
+# 6134 "parsing/parser.ml"
in
-# 1771 "parsing/parser.mly"
+# 1821 "parsing/parser.mly"
( _1 )
-# 6113 "parsing/parser.ml"
+# 6139 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in
let _endpos = _endpos__1_ in
let _startpos = _startpos__1_ in
-# 786 "parsing/parser.mly"
+# 807 "parsing/parser.mly"
( extra_cstr _startpos _endpos _1 )
-# 6122 "parsing/parser.ml"
+# 6148 "parsing/parser.ml"
in
-# 1758 "parsing/parser.mly"
+# 1808 "parsing/parser.mly"
( Cstr.mk _1 _2 )
-# 6128 "parsing/parser.ml"
+# 6154 "parsing/parser.ml"
in
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 6136 "parsing/parser.ml"
+# 6162 "parsing/parser.ml"
in
let _endpos = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1746 "parsing/parser.mly"
+# 1796 "parsing/parser.mly"
( mkclass ~loc:_sloc ~attrs:_2 (Pcl_structure _3) )
-# 6145 "parsing/parser.ml"
+# 6171 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.class_type) =
-# 1849 "parsing/parser.mly"
+# 1899 "parsing/parser.mly"
( _1 )
-# 6170 "parsing/parser.ml"
+# 6196 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.class_type) = let _1 =
let _1 =
let label =
-# 3177 "parsing/parser.mly"
+# 3227 "parsing/parser.mly"
( Optional label )
-# 6218 "parsing/parser.ml"
+# 6244 "parsing/parser.ml"
in
-# 1855 "parsing/parser.mly"
+# 1905 "parsing/parser.mly"
( Pcty_arrow(label, domain, codomain) )
-# 6223 "parsing/parser.ml"
+# 6249 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_label_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 839 "parsing/parser.mly"
+# 860 "parsing/parser.mly"
( mkcty ~loc:_sloc _1 )
-# 6233 "parsing/parser.ml"
+# 6259 "parsing/parser.ml"
in
-# 1856 "parsing/parser.mly"
+# 1906 "parsing/parser.mly"
( _1 )
-# 6239 "parsing/parser.ml"
+# 6265 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let domain : (Parsetree.core_type) = Obj.magic domain in
let _2 : unit = Obj.magic _2 in
let label : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 6288 "parsing/parser.ml"
+# 6314 "parsing/parser.ml"
) = Obj.magic label in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos_label_ in
let _v : (Parsetree.class_type) = let _1 =
let _1 =
let label =
-# 3179 "parsing/parser.mly"
+# 3229 "parsing/parser.mly"
( Labelled label )
-# 6298 "parsing/parser.ml"
+# 6324 "parsing/parser.ml"
in
-# 1855 "parsing/parser.mly"
+# 1905 "parsing/parser.mly"
( Pcty_arrow(label, domain, codomain) )
-# 6303 "parsing/parser.ml"
+# 6329 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_label_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 839 "parsing/parser.mly"
+# 860 "parsing/parser.mly"
( mkcty ~loc:_sloc _1 )
-# 6313 "parsing/parser.ml"
+# 6339 "parsing/parser.ml"
in
-# 1856 "parsing/parser.mly"
+# 1906 "parsing/parser.mly"
( _1 )
-# 6319 "parsing/parser.ml"
+# 6345 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.class_type) = let _1 =
let _1 =
let label =
-# 3181 "parsing/parser.mly"
+# 3231 "parsing/parser.mly"
( Nolabel )
-# 6360 "parsing/parser.ml"
+# 6386 "parsing/parser.ml"
in
-# 1855 "parsing/parser.mly"
+# 1905 "parsing/parser.mly"
( Pcty_arrow(label, domain, codomain) )
-# 6365 "parsing/parser.ml"
+# 6391 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_domain_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 839 "parsing/parser.mly"
+# 860 "parsing/parser.mly"
( mkcty ~loc:_sloc _1 )
-# 6375 "parsing/parser.ml"
+# 6401 "parsing/parser.ml"
in
-# 1856 "parsing/parser.mly"
+# 1906 "parsing/parser.mly"
( _1 )
-# 6381 "parsing/parser.ml"
+# 6407 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let csig : (Parsetree.class_type) = Obj.magic csig in
let _8 : unit = Obj.magic _8 in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 6466 "parsing/parser.ml"
+# 6492 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in
let virt : (Asttypes.virtual_flag) = Obj.magic virt in
let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 6484 "parsing/parser.ml"
+# 6510 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 6496 "parsing/parser.ml"
+# 6522 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 6504 "parsing/parser.ml"
+# 6530 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1994 "parsing/parser.mly"
+# 2044 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
ext,
Ci.mk id csig ~virt ~params ~attrs ~loc ~docs
)
-# 6519 "parsing/parser.ml"
+# 6545 "parsing/parser.ml"
in
-# 1023 "parsing/parser.mly"
+# 1044 "parsing/parser.mly"
( let (x, b) = a in x, b :: bs )
-# 6525 "parsing/parser.ml"
+# 6551 "parsing/parser.ml"
in
-# 1982 "parsing/parser.mly"
+# 2032 "parsing/parser.mly"
( _1 )
-# 6531 "parsing/parser.ml"
+# 6557 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.endp = _endpos__1_;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
- let _1 : (
-# 642 "parsing/parser.mly"
- (string)
-# 6552 "parsing/parser.ml"
- ) = Obj.magic _1 in
- let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
- let _startpos = _startpos__1_ in
- let _endpos = _endpos__1_ in
- let _v : (Longident.t) =
-# 3462 "parsing/parser.mly"
- ( Lident _1 )
-# 6560 "parsing/parser.ml"
- in
- {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = Obj.repr _v;
- MenhirLib.EngineTypes.startp = _startpos;
- MenhirLib.EngineTypes.endp = _endpos;
- MenhirLib.EngineTypes.next = _menhir_stack;
- });
- (fun _menhir_env ->
- let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
- let {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _3;
- MenhirLib.EngineTypes.startp = _startpos__3_;
- MenhirLib.EngineTypes.endp = _endpos__3_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _2;
- MenhirLib.EngineTypes.startp = _startpos__2_;
- MenhirLib.EngineTypes.endp = _endpos__2_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = _1;
- MenhirLib.EngineTypes.startp = _startpos__1_;
- MenhirLib.EngineTypes.endp = _endpos__1_;
- MenhirLib.EngineTypes.next = _menhir_stack;
- };
- };
- } = _menhir_stack in
- let _3 : (
-# 642 "parsing/parser.mly"
- (string)
-# 6593 "parsing/parser.ml"
- ) = Obj.magic _3 in
- let _2 : unit = Obj.magic _2 in
let _1 : (Longident.t) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
- let _endpos = _endpos__3_ in
+ let _endpos = _endpos__1_ in
let _v : (Longident.t) =
-# 3463 "parsing/parser.mly"
- ( Ldot(_1, _3) )
-# 6603 "parsing/parser.ml"
+# 3516 "parsing/parser.mly"
+ ( _1 )
+# 6582 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 628 "parsing/parser.mly"
+# 633 "parsing/parser.mly"
(string * char option)
-# 6624 "parsing/parser.ml"
+# 6603 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.constant) =
-# 3349 "parsing/parser.mly"
+# 3399 "parsing/parser.mly"
( let (n, m) = _1 in Pconst_integer (n, m) )
-# 6632 "parsing/parser.ml"
+# 6611 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 587 "parsing/parser.mly"
+# 592 "parsing/parser.mly"
(char)
-# 6653 "parsing/parser.ml"
+# 6632 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.constant) =
-# 3350 "parsing/parser.mly"
+# 3400 "parsing/parser.mly"
( Pconst_char _1 )
-# 6661 "parsing/parser.ml"
+# 6640 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 680 "parsing/parser.mly"
- (string * string option)
-# 6682 "parsing/parser.ml"
+# 685 "parsing/parser.mly"
+ (string * Location.t * string option)
+# 6661 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.constant) =
-# 3351 "parsing/parser.mly"
- ( let (s, d) = _1 in Pconst_string (s, d) )
-# 6690 "parsing/parser.ml"
+# 3401 "parsing/parser.mly"
+ ( let (s, strloc, d) = _1 in Pconst_string (s, strloc, d) )
+# 6669 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 607 "parsing/parser.mly"
+# 612 "parsing/parser.mly"
(string * char option)
-# 6711 "parsing/parser.ml"
+# 6690 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.constant) =
-# 3352 "parsing/parser.mly"
+# 3402 "parsing/parser.mly"
( let (f, m) = _1 in Pconst_float (f, m) )
-# 6719 "parsing/parser.ml"
- in
- {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = Obj.repr _v;
- MenhirLib.EngineTypes.startp = _startpos;
- MenhirLib.EngineTypes.endp = _endpos;
- MenhirLib.EngineTypes.next = _menhir_stack;
- });
- (fun _menhir_env ->
- let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
- let {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = _1;
- MenhirLib.EngineTypes.startp = _startpos__1_;
- MenhirLib.EngineTypes.endp = _endpos__1_;
- MenhirLib.EngineTypes.next = _menhir_stack;
- } = _menhir_stack in
- let _1 : (
-# 688 "parsing/parser.mly"
- (string)
-# 6740 "parsing/parser.ml"
- ) = Obj.magic _1 in
- let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
- let _startpos = _startpos__1_ in
- let _endpos = _endpos__1_ in
- let _v : (string) =
-# 3416 "parsing/parser.mly"
- ( _1 )
-# 6748 "parsing/parser.ml"
+# 6698 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
- let _v : (string) =
-# 3417 "parsing/parser.mly"
+ let _v : (Asttypes.label) =
+# 3473 "parsing/parser.mly"
( "[]" )
-# 6780 "parsing/parser.ml"
+# 6730 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
- let _v : (string) =
-# 3418 "parsing/parser.mly"
+ let _v : (Asttypes.label) =
+# 3474 "parsing/parser.mly"
( "()" )
+# 6762 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ } = _menhir_stack in
+ let _1 : unit = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_ in
+ let _v : (Asttypes.label) =
+# 3475 "parsing/parser.mly"
+ ( "false" )
+# 6787 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ } = _menhir_stack in
+ let _1 : unit = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_ in
+ let _v : (Asttypes.label) =
+# 3476 "parsing/parser.mly"
+ ( "true" )
# 6812 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.endp = _endpos;
MenhirLib.EngineTypes.next = _menhir_stack;
});
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ } = _menhir_stack in
+ let _1 : (
+# 697 "parsing/parser.mly"
+ (string)
+# 6833 "parsing/parser.ml"
+ ) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_ in
+ let _v : (Asttypes.label) =
+# 3479 "parsing/parser.mly"
+ ( _1 )
+# 6841 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
(fun _menhir_env ->
let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
let {
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
- let _v : (string) =
-# 3419 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3470 "parsing/parser.mly"
( "::" )
-# 6851 "parsing/parser.ml"
+# 6880 "parsing/parser.ml"
in
- {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = Obj.repr _v;
- MenhirLib.EngineTypes.startp = _startpos;
- MenhirLib.EngineTypes.endp = _endpos;
- MenhirLib.EngineTypes.next = _menhir_stack;
- });
- (fun _menhir_env ->
- let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
- let {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = _1;
- MenhirLib.EngineTypes.startp = _startpos__1_;
- MenhirLib.EngineTypes.endp = _endpos__1_;
- MenhirLib.EngineTypes.next = _menhir_stack;
- } = _menhir_stack in
- let _1 : unit = Obj.magic _1 in
- let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
- let _startpos = _startpos__1_ in
- let _endpos = _endpos__1_ in
- let _v : (string) =
-# 3420 "parsing/parser.mly"
- ( "false" )
-# 6876 "parsing/parser.ml"
+
+# 3480 "parsing/parser.mly"
+ ( _1 )
+# 6885 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.endp = _endpos__1_;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
- let _1 : unit = Obj.magic _1 in
+ let _1 : (Asttypes.label) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) =
-# 3421 "parsing/parser.mly"
- ( "true" )
-# 6901 "parsing/parser.ml"
+ let _v : (Asttypes.label) =
+# 3481 "parsing/parser.mly"
+ ( _1 )
+# 6910 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Longident.t) =
-# 3429 "parsing/parser.mly"
- ( _1 )
-# 6926 "parsing/parser.ml"
+# 3484 "parsing/parser.mly"
+ ( _1 )
+# 6935 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
let {
MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _5;
- MenhirLib.EngineTypes.startp = _startpos__5_;
- MenhirLib.EngineTypes.endp = _endpos__5_;
+ MenhirLib.EngineTypes.semv = _3;
+ MenhirLib.EngineTypes.startp = _startpos__3_;
+ MenhirLib.EngineTypes.endp = _endpos__3_;
MenhirLib.EngineTypes.next = {
MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _4;
- MenhirLib.EngineTypes.startp = _startpos__4_;
- MenhirLib.EngineTypes.endp = _endpos__4_;
+ MenhirLib.EngineTypes.semv = _2_inlined1;
+ MenhirLib.EngineTypes.startp = _startpos__2_inlined1_;
+ MenhirLib.EngineTypes.endp = _endpos__2_inlined1_;
MenhirLib.EngineTypes.next = {
MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _3;
- MenhirLib.EngineTypes.startp = _startpos__3_;
- MenhirLib.EngineTypes.endp = _endpos__3_;
+ MenhirLib.EngineTypes.semv = _1_inlined1;
+ MenhirLib.EngineTypes.startp = _startpos__1_inlined1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_inlined1_;
MenhirLib.EngineTypes.next = {
MenhirLib.EngineTypes.state = _;
MenhirLib.EngineTypes.semv = _2;
};
};
} = _menhir_stack in
- let _5 : unit = Obj.magic _5 in
- let _4 : unit = Obj.magic _4 in
let _3 : unit = Obj.magic _3 in
+ let _2_inlined1 : unit = Obj.magic _2_inlined1 in
+ let _1_inlined1 : unit = Obj.magic _1_inlined1 in
let _2 : unit = Obj.magic _2 in
let _1 : (Longident.t) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
- let _endpos = _endpos__5_ in
- let _v : (Longident.t) =
-# 3430 "parsing/parser.mly"
- ( Ldot(_1,"::") )
-# 6979 "parsing/parser.ml"
+ let _endpos = _endpos__3_ in
+ let _v : (Longident.t) = let _3 =
+ let (_2, _1) = (_2_inlined1, _1_inlined1) in
+
+# 3470 "parsing/parser.mly"
+ ( "::" )
+# 6990 "parsing/parser.ml"
+
+ in
+
+# 3485 "parsing/parser.mly"
+ ( Ldot(_1,_3) )
+# 6996 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
let {
MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _2;
- MenhirLib.EngineTypes.startp = _startpos__2_;
- MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.semv = _3;
+ MenhirLib.EngineTypes.startp = _startpos__3_;
+ MenhirLib.EngineTypes.endp = _endpos__3_;
MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = _1;
- MenhirLib.EngineTypes.startp = _startpos__1_;
- MenhirLib.EngineTypes.endp = _endpos__1_;
- MenhirLib.EngineTypes.next = _menhir_stack;
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2;
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
};
} = _menhir_stack in
+ let _3 : unit = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _1 : unit = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
- let _endpos = _endpos__2_ in
- let _v : (Longident.t) =
-# 3431 "parsing/parser.mly"
- ( Lident "[]" )
-# 7011 "parsing/parser.ml"
+ let _endpos = _endpos__3_ in
+ let _v : (Longident.t) = let _1 =
+# 3470 "parsing/parser.mly"
+ ( "::" )
+# 7035 "parsing/parser.ml"
+ in
+
+# 3486 "parsing/parser.mly"
+ ( Lident _1 )
+# 7040 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
(fun _menhir_env ->
let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
let {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _2;
- MenhirLib.EngineTypes.startp = _startpos__2_;
- MenhirLib.EngineTypes.endp = _endpos__2_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = _1;
- MenhirLib.EngineTypes.startp = _startpos__1_;
- MenhirLib.EngineTypes.endp = _endpos__1_;
- MenhirLib.EngineTypes.next = _menhir_stack;
- };
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
- let _2 : unit = Obj.magic _2 in
- let _1 : unit = Obj.magic _1 in
+ let _1 : (Asttypes.label) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
- let _endpos = _endpos__2_ in
+ let _endpos = _endpos__1_ in
let _v : (Longident.t) =
-# 3432 "parsing/parser.mly"
- ( Lident "()" )
-# 7043 "parsing/parser.ml"
- in
- {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = Obj.repr _v;
- MenhirLib.EngineTypes.startp = _startpos;
- MenhirLib.EngineTypes.endp = _endpos;
- MenhirLib.EngineTypes.next = _menhir_stack;
- });
- (fun _menhir_env ->
- let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
- let {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _3;
- MenhirLib.EngineTypes.startp = _startpos__3_;
- MenhirLib.EngineTypes.endp = _endpos__3_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _2;
- MenhirLib.EngineTypes.startp = _startpos__2_;
- MenhirLib.EngineTypes.endp = _endpos__2_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = _1;
- MenhirLib.EngineTypes.startp = _startpos__1_;
- MenhirLib.EngineTypes.endp = _endpos__1_;
- MenhirLib.EngineTypes.next = _menhir_stack;
- };
- };
- } = _menhir_stack in
- let _3 : unit = Obj.magic _3 in
- let _2 : unit = Obj.magic _2 in
- let _1 : unit = Obj.magic _1 in
- let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
- let _startpos = _startpos__1_ in
- let _endpos = _endpos__3_ in
- let _v : (Longident.t) =
-# 3433 "parsing/parser.mly"
- ( Lident "::" )
-# 7082 "parsing/parser.ml"
- in
- {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = Obj.repr _v;
- MenhirLib.EngineTypes.startp = _startpos;
- MenhirLib.EngineTypes.endp = _endpos;
- MenhirLib.EngineTypes.next = _menhir_stack;
- });
- (fun _menhir_env ->
- let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
- let {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = _1;
- MenhirLib.EngineTypes.startp = _startpos__1_;
- MenhirLib.EngineTypes.endp = _endpos__1_;
- MenhirLib.EngineTypes.next = _menhir_stack;
- } = _menhir_stack in
- let _1 : unit = Obj.magic _1 in
- let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
- let _startpos = _startpos__1_ in
- let _endpos = _endpos__1_ in
- let _v : (Longident.t) =
-# 3434 "parsing/parser.mly"
- ( Lident "false" )
-# 7107 "parsing/parser.ml"
- in
- {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = Obj.repr _v;
- MenhirLib.EngineTypes.startp = _startpos;
- MenhirLib.EngineTypes.endp = _endpos;
- MenhirLib.EngineTypes.next = _menhir_stack;
- });
- (fun _menhir_env ->
- let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
- let {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = _1;
- MenhirLib.EngineTypes.startp = _startpos__1_;
- MenhirLib.EngineTypes.endp = _endpos__1_;
- MenhirLib.EngineTypes.next = _menhir_stack;
- } = _menhir_stack in
- let _1 : unit = Obj.magic _1 in
- let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
- let _startpos = _startpos__1_ in
- let _endpos = _endpos__1_ in
- let _v : (Longident.t) =
-# 3435 "parsing/parser.mly"
- ( Lident "true" )
-# 7132 "parsing/parser.ml"
+# 3487 "parsing/parser.mly"
+ ( Lident _1 )
+# 7065 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.core_type * Parsetree.core_type) =
-# 1938 "parsing/parser.mly"
+# 1988 "parsing/parser.mly"
( _1, _3 )
-# 7171 "parsing/parser.ml"
+# 7104 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.constructor_arguments) = let tys =
let xs =
let xs =
-# 910 "parsing/parser.mly"
+# 931 "parsing/parser.mly"
( [ x ] )
-# 7198 "parsing/parser.ml"
+# 7131 "parsing/parser.ml"
in
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 7203 "parsing/parser.ml"
+# 7136 "parsing/parser.ml"
in
-# 930 "parsing/parser.mly"
+# 951 "parsing/parser.mly"
( xs )
-# 7209 "parsing/parser.ml"
+# 7142 "parsing/parser.ml"
in
-# 2984 "parsing/parser.mly"
+# 3034 "parsing/parser.mly"
( Pcstr_tuple tys )
-# 7215 "parsing/parser.ml"
+# 7148 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.constructor_arguments) = let tys =
let xs =
let xs =
-# 914 "parsing/parser.mly"
+# 935 "parsing/parser.mly"
( x :: xs )
-# 7256 "parsing/parser.ml"
+# 7189 "parsing/parser.ml"
in
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 7261 "parsing/parser.ml"
+# 7194 "parsing/parser.ml"
in
-# 930 "parsing/parser.mly"
+# 951 "parsing/parser.mly"
( xs )
-# 7267 "parsing/parser.ml"
+# 7200 "parsing/parser.ml"
in
-# 2984 "parsing/parser.mly"
+# 3034 "parsing/parser.mly"
( Pcstr_tuple tys )
-# 7273 "parsing/parser.ml"
+# 7206 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.constructor_arguments) =
-# 2986 "parsing/parser.mly"
+# 3036 "parsing/parser.mly"
( Pcstr_record _2 )
-# 7312 "parsing/parser.ml"
+# 7245 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.constructor_declaration list) =
-# 2905 "parsing/parser.mly"
+# 2955 "parsing/parser.mly"
( [] )
-# 7337 "parsing/parser.ml"
+# 7270 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xs_ in
let _endpos = _endpos_xs_ in
let _v : (Parsetree.constructor_declaration list) = let cs =
-# 1015 "parsing/parser.mly"
+# 1036 "parsing/parser.mly"
( List.rev xs )
-# 7362 "parsing/parser.ml"
+# 7295 "parsing/parser.ml"
in
-# 2907 "parsing/parser.mly"
+# 2957 "parsing/parser.mly"
( cs )
-# 7367 "parsing/parser.ml"
+# 7300 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.core_type) = let _1 =
-# 3139 "parsing/parser.mly"
+# 3189 "parsing/parser.mly"
( _1 )
-# 7392 "parsing/parser.ml"
+# 7325 "parsing/parser.ml"
in
-# 3129 "parsing/parser.mly"
+# 3179 "parsing/parser.mly"
( _1 )
-# 7397 "parsing/parser.ml"
+# 7330 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.core_type) =
-# 3131 "parsing/parser.mly"
+# 3181 "parsing/parser.mly"
( Typ.attr _1 _2 )
-# 7429 "parsing/parser.ml"
+# 7362 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.direction_flag) =
-# 3516 "parsing/parser.mly"
+# 3578 "parsing/parser.mly"
( Upto )
-# 7454 "parsing/parser.ml"
+# 7387 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.direction_flag) =
-# 3517 "parsing/parser.mly"
+# 3579 "parsing/parser.mly"
( Downto )
-# 7479 "parsing/parser.ml"
+# 7412 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.expression) =
-# 2085 "parsing/parser.mly"
+# 2135 "parsing/parser.mly"
( _1 )
-# 7504 "parsing/parser.ml"
+# 7437 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 7584 "parsing/parser.ml"
+# 7517 "parsing/parser.ml"
in
let _3 =
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 7594 "parsing/parser.ml"
+# 7527 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 7600 "parsing/parser.ml"
+# 7533 "parsing/parser.ml"
in
-# 2133 "parsing/parser.mly"
+# 2183 "parsing/parser.mly"
( Pexp_letmodule(_4, _5, _7), _3 )
-# 7606 "parsing/parser.ml"
+# 7539 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 7617 "parsing/parser.ml"
+# 7550 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _5 : unit = Obj.magic _5 in
let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in
let _2_inlined1 : (Parsetree.constructor_arguments * Parsetree.core_type option) = Obj.magic _2_inlined1 in
- let _1_inlined3 : (string) = Obj.magic _1_inlined3 in
+ let _1_inlined3 : (Asttypes.label) = Obj.magic _1_inlined3 in
let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in
let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in
let _2 : unit = Obj.magic _2 in
let _3 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 7703 "parsing/parser.ml"
+# 7636 "parsing/parser.ml"
in
let _endpos__3_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 7714 "parsing/parser.ml"
+# 7647 "parsing/parser.ml"
in
let _endpos = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2969 "parsing/parser.mly"
+# 3019 "parsing/parser.mly"
( let args, res = _2 in
Te.decl _1 ~args ?res ~attrs:_3 ~loc:(make_loc _sloc) )
-# 7724 "parsing/parser.ml"
+# 7657 "parsing/parser.ml"
in
let _3 =
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 7734 "parsing/parser.ml"
+# 7667 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 7740 "parsing/parser.ml"
+# 7673 "parsing/parser.ml"
in
-# 2135 "parsing/parser.mly"
+# 2185 "parsing/parser.mly"
( Pexp_letexception(_4, _6), _3 )
-# 7746 "parsing/parser.ml"
+# 7679 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__6_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 7757 "parsing/parser.ml"
+# 7690 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 7829 "parsing/parser.ml"
+# 7762 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 7835 "parsing/parser.ml"
+# 7768 "parsing/parser.ml"
in
let _3 =
-# 3571 "parsing/parser.mly"
+# 3633 "parsing/parser.mly"
( Fresh )
-# 7841 "parsing/parser.ml"
+# 7774 "parsing/parser.ml"
in
-# 2137 "parsing/parser.mly"
+# 2187 "parsing/parser.mly"
( let open_loc = make_loc (_startpos__2_, _endpos__5_) in
let od = Opn.mk _5 ~override:_3 ~loc:open_loc in
Pexp_open(od, _7), _4 )
-# 7848 "parsing/parser.ml"
+# 7781 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 7859 "parsing/parser.ml"
+# 7792 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 7938 "parsing/parser.ml"
+# 7871 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 7944 "parsing/parser.ml"
+# 7877 "parsing/parser.ml"
in
let _3 =
let _1 = _1_inlined1 in
-# 3572 "parsing/parser.mly"
+# 3634 "parsing/parser.mly"
( Override )
-# 7952 "parsing/parser.ml"
+# 7885 "parsing/parser.ml"
in
-# 2137 "parsing/parser.mly"
+# 2187 "parsing/parser.mly"
( let open_loc = make_loc (_startpos__2_, _endpos__5_) in
let od = Opn.mk _5 ~override:_3 ~loc:open_loc in
Pexp_open(od, _7), _4 )
-# 7960 "parsing/parser.ml"
+# 7893 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 7971 "parsing/parser.ml"
+# 7904 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 =
let xs =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 8020 "parsing/parser.ml"
+# 7953 "parsing/parser.ml"
in
-# 987 "parsing/parser.mly"
+# 1008 "parsing/parser.mly"
( xs )
-# 8025 "parsing/parser.ml"
+# 7958 "parsing/parser.ml"
in
-# 2469 "parsing/parser.mly"
+# 2519 "parsing/parser.mly"
( xs )
-# 8031 "parsing/parser.ml"
+# 7964 "parsing/parser.ml"
in
let _2 =
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 8041 "parsing/parser.ml"
+# 7974 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 8047 "parsing/parser.ml"
+# 7980 "parsing/parser.ml"
in
-# 2141 "parsing/parser.mly"
+# 2191 "parsing/parser.mly"
( Pexp_function _3, _2 )
-# 8053 "parsing/parser.ml"
+# 7986 "parsing/parser.ml"
in
let _endpos__1_ = _endpos_xs_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 8064 "parsing/parser.ml"
+# 7997 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 8122 "parsing/parser.ml"
+# 8055 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 8128 "parsing/parser.ml"
+# 8061 "parsing/parser.ml"
in
-# 2143 "parsing/parser.mly"
+# 2193 "parsing/parser.mly"
( let (l,o,p) = _3 in
Pexp_fun(l, o, p, _4), _2 )
-# 8135 "parsing/parser.ml"
+# 8068 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 8146 "parsing/parser.ml"
+# 8079 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__7_ in
let _v : (Parsetree.expression) = let _1 =
let _5 =
-# 2364 "parsing/parser.mly"
+# 2414 "parsing/parser.mly"
( xs )
-# 8221 "parsing/parser.ml"
+# 8154 "parsing/parser.ml"
in
let _2 =
let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 8230 "parsing/parser.ml"
+# 8163 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 8236 "parsing/parser.ml"
+# 8169 "parsing/parser.ml"
in
let _endpos = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2146 "parsing/parser.mly"
+# 2196 "parsing/parser.mly"
( (mk_newtypes ~loc:_sloc _5 _7).pexp_desc, _2 )
-# 8245 "parsing/parser.ml"
+# 8178 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 8256 "parsing/parser.ml"
+# 8189 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _5 =
let xs =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 8319 "parsing/parser.ml"
+# 8252 "parsing/parser.ml"
in
-# 987 "parsing/parser.mly"
+# 1008 "parsing/parser.mly"
( xs )
-# 8324 "parsing/parser.ml"
+# 8257 "parsing/parser.ml"
in
-# 2469 "parsing/parser.mly"
+# 2519 "parsing/parser.mly"
( xs )
-# 8330 "parsing/parser.ml"
+# 8263 "parsing/parser.ml"
in
let _2 =
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 8340 "parsing/parser.ml"
+# 8273 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 8346 "parsing/parser.ml"
+# 8279 "parsing/parser.ml"
in
-# 2148 "parsing/parser.mly"
+# 2198 "parsing/parser.mly"
( Pexp_match(_3, _5), _2 )
-# 8352 "parsing/parser.ml"
+# 8285 "parsing/parser.ml"
in
let _endpos__1_ = _endpos_xs_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 8363 "parsing/parser.ml"
+# 8296 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _5 =
let xs =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 8426 "parsing/parser.ml"
+# 8359 "parsing/parser.ml"
in
-# 987 "parsing/parser.mly"
+# 1008 "parsing/parser.mly"
( xs )
-# 8431 "parsing/parser.ml"
+# 8364 "parsing/parser.ml"
in
-# 2469 "parsing/parser.mly"
+# 2519 "parsing/parser.mly"
( xs )
-# 8437 "parsing/parser.ml"
+# 8370 "parsing/parser.ml"
in
let _2 =
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 8447 "parsing/parser.ml"
+# 8380 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 8453 "parsing/parser.ml"
+# 8386 "parsing/parser.ml"
in
-# 2150 "parsing/parser.mly"
+# 2200 "parsing/parser.mly"
( Pexp_try(_3, _5), _2 )
-# 8459 "parsing/parser.ml"
+# 8392 "parsing/parser.ml"
in
let _endpos__1_ = _endpos_xs_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 8470 "parsing/parser.ml"
+# 8403 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 8535 "parsing/parser.ml"
+# 8468 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 8541 "parsing/parser.ml"
+# 8474 "parsing/parser.ml"
in
-# 2152 "parsing/parser.mly"
+# 2202 "parsing/parser.mly"
( syntax_error() )
-# 8547 "parsing/parser.ml"
+# 8480 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 8558 "parsing/parser.ml"
+# 8491 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 8637 "parsing/parser.ml"
+# 8570 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 8643 "parsing/parser.ml"
+# 8576 "parsing/parser.ml"
in
-# 2154 "parsing/parser.mly"
+# 2204 "parsing/parser.mly"
( Pexp_ifthenelse(_3, _5, Some _7), _2 )
-# 8649 "parsing/parser.ml"
+# 8582 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 8660 "parsing/parser.ml"
+# 8593 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 8725 "parsing/parser.ml"
+# 8658 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 8731 "parsing/parser.ml"
+# 8664 "parsing/parser.ml"
in
-# 2156 "parsing/parser.mly"
+# 2206 "parsing/parser.mly"
( Pexp_ifthenelse(_3, _5, None), _2 )
-# 8737 "parsing/parser.ml"
+# 8670 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 8748 "parsing/parser.ml"
+# 8681 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 8820 "parsing/parser.ml"
+# 8753 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 8826 "parsing/parser.ml"
+# 8759 "parsing/parser.ml"
in
-# 2158 "parsing/parser.mly"
+# 2208 "parsing/parser.mly"
( Pexp_while(_3, _5), _2 )
-# 8832 "parsing/parser.ml"
+# 8765 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__6_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 8843 "parsing/parser.ml"
+# 8776 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 8943 "parsing/parser.ml"
+# 8876 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 8949 "parsing/parser.ml"
+# 8882 "parsing/parser.ml"
in
-# 2161 "parsing/parser.mly"
+# 2211 "parsing/parser.mly"
( Pexp_for(_3, _5, _7, _6, _9), _2 )
-# 8955 "parsing/parser.ml"
+# 8888 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__10_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 8966 "parsing/parser.ml"
+# 8899 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 9017 "parsing/parser.ml"
+# 8950 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 9023 "parsing/parser.ml"
+# 8956 "parsing/parser.ml"
in
-# 2163 "parsing/parser.mly"
+# 2213 "parsing/parser.mly"
( Pexp_assert _3, _2 )
-# 9029 "parsing/parser.ml"
+# 8962 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 9040 "parsing/parser.ml"
+# 8973 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 9091 "parsing/parser.ml"
+# 9024 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 9097 "parsing/parser.ml"
+# 9030 "parsing/parser.ml"
in
-# 2165 "parsing/parser.mly"
+# 2215 "parsing/parser.mly"
( Pexp_lazy _3, _2 )
-# 9103 "parsing/parser.ml"
+# 9036 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 9114 "parsing/parser.ml"
+# 9047 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 =
let _1 =
-# 260 "menhir/standard.mly"
+# 260 "<standard.mly>"
( List.flatten xss )
-# 9179 "parsing/parser.ml"
+# 9112 "parsing/parser.ml"
in
-# 1771 "parsing/parser.mly"
+# 1821 "parsing/parser.mly"
( _1 )
-# 9184 "parsing/parser.ml"
+# 9117 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in
let _endpos = _endpos__1_ in
let _startpos = _startpos__1_ in
-# 786 "parsing/parser.mly"
+# 807 "parsing/parser.mly"
( extra_cstr _startpos _endpos _1 )
-# 9193 "parsing/parser.ml"
+# 9126 "parsing/parser.ml"
in
-# 1758 "parsing/parser.mly"
+# 1808 "parsing/parser.mly"
( Cstr.mk _1 _2 )
-# 9199 "parsing/parser.ml"
+# 9132 "parsing/parser.ml"
in
let _2 =
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 9209 "parsing/parser.ml"
+# 9142 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 9215 "parsing/parser.ml"
+# 9148 "parsing/parser.ml"
in
-# 2167 "parsing/parser.mly"
+# 2217 "parsing/parser.mly"
( Pexp_object _3, _2 )
-# 9221 "parsing/parser.ml"
+# 9154 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 9232 "parsing/parser.ml"
+# 9165 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 =
let _1 =
-# 260 "menhir/standard.mly"
+# 260 "<standard.mly>"
( List.flatten xss )
-# 9297 "parsing/parser.ml"
+# 9230 "parsing/parser.ml"
in
-# 1771 "parsing/parser.mly"
+# 1821 "parsing/parser.mly"
( _1 )
-# 9302 "parsing/parser.ml"
+# 9235 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in
let _endpos = _endpos__1_ in
let _startpos = _startpos__1_ in
-# 786 "parsing/parser.mly"
+# 807 "parsing/parser.mly"
( extra_cstr _startpos _endpos _1 )
-# 9311 "parsing/parser.ml"
+# 9244 "parsing/parser.ml"
in
-# 1758 "parsing/parser.mly"
+# 1808 "parsing/parser.mly"
( Cstr.mk _1 _2 )
-# 9317 "parsing/parser.ml"
+# 9250 "parsing/parser.ml"
in
let _2 =
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 9327 "parsing/parser.ml"
+# 9260 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 9333 "parsing/parser.ml"
+# 9266 "parsing/parser.ml"
in
let _loc__4_ = (_startpos__4_, _endpos__4_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2169 "parsing/parser.mly"
+# 2219 "parsing/parser.mly"
( unclosed "object" _loc__1_ "end" _loc__4_ )
-# 9341 "parsing/parser.ml"
+# 9274 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2087 "parsing/parser.mly"
+# 2137 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 9352 "parsing/parser.ml"
+# 9285 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _2 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 9387 "parsing/parser.ml"
+# 9320 "parsing/parser.ml"
in
-# 894 "parsing/parser.mly"
+# 915 "parsing/parser.mly"
( xs )
-# 9392 "parsing/parser.ml"
+# 9325 "parsing/parser.ml"
in
-# 2173 "parsing/parser.mly"
+# 2223 "parsing/parser.mly"
( Pexp_apply(_1, _2) )
-# 9398 "parsing/parser.ml"
+# 9331 "parsing/parser.ml"
in
let _endpos__1_ = _endpos_xs_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 9408 "parsing/parser.ml"
+# 9341 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 9414 "parsing/parser.ml"
+# 9347 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let es =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 9443 "parsing/parser.ml"
+# 9376 "parsing/parser.ml"
in
-# 954 "parsing/parser.mly"
+# 975 "parsing/parser.mly"
( xs )
-# 9448 "parsing/parser.ml"
+# 9381 "parsing/parser.ml"
in
-# 2496 "parsing/parser.mly"
+# 2546 "parsing/parser.mly"
( es )
-# 9454 "parsing/parser.ml"
+# 9387 "parsing/parser.ml"
in
-# 2175 "parsing/parser.mly"
+# 2225 "parsing/parser.mly"
( Pexp_tuple(_1) )
-# 9460 "parsing/parser.ml"
+# 9393 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_xs_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 9470 "parsing/parser.ml"
+# 9403 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 9476 "parsing/parser.ml"
+# 9409 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 9514 "parsing/parser.ml"
+# 9447 "parsing/parser.ml"
in
-# 2177 "parsing/parser.mly"
+# 2227 "parsing/parser.mly"
( Pexp_construct(_1, Some _2) )
-# 9520 "parsing/parser.ml"
+# 9453 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 9530 "parsing/parser.ml"
+# 9463 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 9536 "parsing/parser.ml"
+# 9469 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__2_ in
let _v : (Parsetree.expression) = let _1 =
let _1 =
-# 2179 "parsing/parser.mly"
+# 2229 "parsing/parser.mly"
( Pexp_variant(_1, Some _2) )
-# 9569 "parsing/parser.ml"
+# 9502 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 9578 "parsing/parser.ml"
+# 9511 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 9584 "parsing/parser.ml"
+# 9517 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let e2 : (Parsetree.expression) = Obj.magic e2 in
let op : (
-# 618 "parsing/parser.mly"
+# 623 "parsing/parser.mly"
(string)
-# 9618 "parsing/parser.ml"
+# 9551 "parsing/parser.ml"
) = Obj.magic op in
let e1 : (Parsetree.expression) = Obj.magic e1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _1 =
let op =
let _1 =
-# 3390 "parsing/parser.mly"
+# 3443 "parsing/parser.mly"
( op )
-# 9630 "parsing/parser.ml"
+# 9563 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 9639 "parsing/parser.ml"
+# 9572 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 9645 "parsing/parser.ml"
+# 9578 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 9655 "parsing/parser.ml"
+# 9588 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 9661 "parsing/parser.ml"
+# 9594 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let e2 : (Parsetree.expression) = Obj.magic e2 in
let op : (
-# 619 "parsing/parser.mly"
+# 624 "parsing/parser.mly"
(string)
-# 9695 "parsing/parser.ml"
+# 9628 "parsing/parser.ml"
) = Obj.magic op in
let e1 : (Parsetree.expression) = Obj.magic e1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _1 =
let op =
let _1 =
-# 3391 "parsing/parser.mly"
+# 3444 "parsing/parser.mly"
( op )
-# 9707 "parsing/parser.ml"
+# 9640 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 9716 "parsing/parser.ml"
+# 9649 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 9722 "parsing/parser.ml"
+# 9655 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 9732 "parsing/parser.ml"
+# 9665 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 9738 "parsing/parser.ml"
+# 9671 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let e2 : (Parsetree.expression) = Obj.magic e2 in
let op : (
-# 620 "parsing/parser.mly"
+# 625 "parsing/parser.mly"
(string)
-# 9772 "parsing/parser.ml"
+# 9705 "parsing/parser.ml"
) = Obj.magic op in
let e1 : (Parsetree.expression) = Obj.magic e1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _1 =
let op =
let _1 =
-# 3392 "parsing/parser.mly"
+# 3445 "parsing/parser.mly"
( op )
-# 9784 "parsing/parser.ml"
+# 9717 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 9793 "parsing/parser.ml"
+# 9726 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 9799 "parsing/parser.ml"
+# 9732 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 9809 "parsing/parser.ml"
+# 9742 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 9815 "parsing/parser.ml"
+# 9748 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let e2 : (Parsetree.expression) = Obj.magic e2 in
let op : (
-# 621 "parsing/parser.mly"
+# 626 "parsing/parser.mly"
(string)
-# 9849 "parsing/parser.ml"
+# 9782 "parsing/parser.ml"
) = Obj.magic op in
let e1 : (Parsetree.expression) = Obj.magic e1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _1 =
let op =
let _1 =
-# 3393 "parsing/parser.mly"
+# 3446 "parsing/parser.mly"
( op )
-# 9861 "parsing/parser.ml"
+# 9794 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 9870 "parsing/parser.ml"
+# 9803 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 9876 "parsing/parser.ml"
+# 9809 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 9886 "parsing/parser.ml"
+# 9819 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 9892 "parsing/parser.ml"
+# 9825 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let e2 : (Parsetree.expression) = Obj.magic e2 in
let op : (
-# 622 "parsing/parser.mly"
+# 627 "parsing/parser.mly"
(string)
-# 9926 "parsing/parser.ml"
+# 9859 "parsing/parser.ml"
) = Obj.magic op in
let e1 : (Parsetree.expression) = Obj.magic e1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _1 =
let op =
let _1 =
-# 3394 "parsing/parser.mly"
+# 3447 "parsing/parser.mly"
( op )
-# 9938 "parsing/parser.ml"
+# 9871 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 9947 "parsing/parser.ml"
+# 9880 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 9953 "parsing/parser.ml"
+# 9886 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 9963 "parsing/parser.ml"
+# 9896 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 9969 "parsing/parser.ml"
+# 9902 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let op =
let _1 =
-# 3395 "parsing/parser.mly"
+# 3448 "parsing/parser.mly"
("+")
-# 10011 "parsing/parser.ml"
+# 9944 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 10019 "parsing/parser.ml"
+# 9952 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 10025 "parsing/parser.ml"
+# 9958 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 10035 "parsing/parser.ml"
+# 9968 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 10041 "parsing/parser.ml"
+# 9974 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let op =
let _1 =
-# 3396 "parsing/parser.mly"
+# 3449 "parsing/parser.mly"
("+.")
-# 10083 "parsing/parser.ml"
+# 10016 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 10091 "parsing/parser.ml"
+# 10024 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 10097 "parsing/parser.ml"
+# 10030 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 10107 "parsing/parser.ml"
+# 10040 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 10113 "parsing/parser.ml"
+# 10046 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let op =
let _1 =
-# 3397 "parsing/parser.mly"
+# 3450 "parsing/parser.mly"
("+=")
-# 10155 "parsing/parser.ml"
+# 10088 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 10163 "parsing/parser.ml"
+# 10096 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 10169 "parsing/parser.ml"
+# 10102 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 10179 "parsing/parser.ml"
+# 10112 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 10185 "parsing/parser.ml"
+# 10118 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let op =
let _1 =
-# 3398 "parsing/parser.mly"
+# 3451 "parsing/parser.mly"
("-")
-# 10227 "parsing/parser.ml"
+# 10160 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 10235 "parsing/parser.ml"
+# 10168 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 10241 "parsing/parser.ml"
+# 10174 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 10251 "parsing/parser.ml"
+# 10184 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 10257 "parsing/parser.ml"
+# 10190 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let op =
let _1 =
-# 3399 "parsing/parser.mly"
+# 3452 "parsing/parser.mly"
("-.")
-# 10299 "parsing/parser.ml"
+# 10232 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 10307 "parsing/parser.ml"
+# 10240 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 10313 "parsing/parser.ml"
+# 10246 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 10323 "parsing/parser.ml"
+# 10256 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 10329 "parsing/parser.ml"
+# 10262 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let op =
let _1 =
-# 3400 "parsing/parser.mly"
+# 3453 "parsing/parser.mly"
("*")
-# 10371 "parsing/parser.ml"
+# 10304 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 10379 "parsing/parser.ml"
+# 10312 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 10385 "parsing/parser.ml"
+# 10318 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 10395 "parsing/parser.ml"
+# 10328 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 10401 "parsing/parser.ml"
+# 10334 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let op =
let _1 =
-# 3401 "parsing/parser.mly"
+# 3454 "parsing/parser.mly"
("%")
-# 10443 "parsing/parser.ml"
+# 10376 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 10451 "parsing/parser.ml"
+# 10384 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 10457 "parsing/parser.ml"
+# 10390 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 10467 "parsing/parser.ml"
+# 10400 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 10473 "parsing/parser.ml"
+# 10406 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let op =
let _1 =
-# 3402 "parsing/parser.mly"
+# 3455 "parsing/parser.mly"
("=")
-# 10515 "parsing/parser.ml"
+# 10448 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 10523 "parsing/parser.ml"
+# 10456 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 10529 "parsing/parser.ml"
+# 10462 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 10539 "parsing/parser.ml"
+# 10472 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 10545 "parsing/parser.ml"
+# 10478 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let op =
let _1 =
-# 3403 "parsing/parser.mly"
+# 3456 "parsing/parser.mly"
("<")
-# 10587 "parsing/parser.ml"
+# 10520 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 10595 "parsing/parser.ml"
+# 10528 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 10601 "parsing/parser.ml"
+# 10534 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 10611 "parsing/parser.ml"
+# 10544 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 10617 "parsing/parser.ml"
+# 10550 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let op =
let _1 =
-# 3404 "parsing/parser.mly"
+# 3457 "parsing/parser.mly"
(">")
-# 10659 "parsing/parser.ml"
+# 10592 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 10667 "parsing/parser.ml"
+# 10600 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 10673 "parsing/parser.ml"
+# 10606 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 10683 "parsing/parser.ml"
+# 10616 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 10689 "parsing/parser.ml"
+# 10622 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let op =
let _1 =
-# 3405 "parsing/parser.mly"
+# 3458 "parsing/parser.mly"
("or")
-# 10731 "parsing/parser.ml"
+# 10664 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 10739 "parsing/parser.ml"
+# 10672 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 10745 "parsing/parser.ml"
+# 10678 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 10755 "parsing/parser.ml"
+# 10688 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 10761 "parsing/parser.ml"
+# 10694 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let op =
let _1 =
-# 3406 "parsing/parser.mly"
+# 3459 "parsing/parser.mly"
("||")
-# 10803 "parsing/parser.ml"
+# 10736 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 10811 "parsing/parser.ml"
+# 10744 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 10817 "parsing/parser.ml"
+# 10750 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 10827 "parsing/parser.ml"
+# 10760 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 10833 "parsing/parser.ml"
+# 10766 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let op =
let _1 =
-# 3407 "parsing/parser.mly"
+# 3460 "parsing/parser.mly"
("&")
-# 10875 "parsing/parser.ml"
+# 10808 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 10883 "parsing/parser.ml"
+# 10816 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 10889 "parsing/parser.ml"
+# 10822 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 10899 "parsing/parser.ml"
+# 10832 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 10905 "parsing/parser.ml"
+# 10838 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let op =
let _1 =
-# 3408 "parsing/parser.mly"
+# 3461 "parsing/parser.mly"
("&&")
-# 10947 "parsing/parser.ml"
+# 10880 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 10955 "parsing/parser.ml"
+# 10888 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 10961 "parsing/parser.ml"
+# 10894 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 10971 "parsing/parser.ml"
+# 10904 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 10977 "parsing/parser.ml"
+# 10910 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let op =
let _1 =
-# 3409 "parsing/parser.mly"
+# 3462 "parsing/parser.mly"
(":=")
-# 11019 "parsing/parser.ml"
+# 10952 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 11027 "parsing/parser.ml"
+# 10960 "parsing/parser.ml"
in
-# 2181 "parsing/parser.mly"
+# 2231 "parsing/parser.mly"
( mkinfix e1 op e2 )
-# 11033 "parsing/parser.ml"
+# 10966 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 11043 "parsing/parser.ml"
+# 10976 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 11049 "parsing/parser.ml"
+# 10982 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2183 "parsing/parser.mly"
+# 2233 "parsing/parser.mly"
( mkuminus ~oploc:_loc__1_ _1 _2 )
-# 11084 "parsing/parser.ml"
+# 11017 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 11094 "parsing/parser.ml"
+# 11027 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 11100 "parsing/parser.ml"
+# 11033 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2185 "parsing/parser.mly"
+# 2235 "parsing/parser.mly"
( mkuplus ~oploc:_loc__1_ _1 _2 )
-# 11135 "parsing/parser.ml"
+# 11068 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 11145 "parsing/parser.ml"
+# 11078 "parsing/parser.ml"
in
-# 2090 "parsing/parser.mly"
+# 2140 "parsing/parser.mly"
( _1 )
-# 11151 "parsing/parser.ml"
+# 11084 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2092 "parsing/parser.mly"
+# 2142 "parsing/parser.mly"
( expr_of_let_bindings ~loc:_sloc _1 _3 )
-# 11193 "parsing/parser.ml"
+# 11126 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 : unit = Obj.magic _3 in
let bindings : (Parsetree.pattern * Parsetree.expression * Parsetree.binding_op list) = Obj.magic bindings in
let _1 : (
-# 624 "parsing/parser.mly"
+# 629 "parsing/parser.mly"
(string)
-# 11235 "parsing/parser.ml"
+# 11168 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 11247 "parsing/parser.ml"
+# 11180 "parsing/parser.ml"
in
let _startpos_pbop_op_ = _startpos__1_ in
let _symbolstartpos = _startpos_pbop_op_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2094 "parsing/parser.mly"
+# 2144 "parsing/parser.mly"
( let (pbop_pat, pbop_exp, rev_ands) = bindings in
let ands = List.rev rev_ands in
let pbop_loc = make_loc _sloc in
let let_ = {pbop_op; pbop_pat; pbop_exp; pbop_loc} in
mkexp ~loc:_sloc (Pexp_letop{ let_; ands; body}) )
-# 11261 "parsing/parser.ml"
+# 11194 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _loc__2_ = (_startpos__2_, _endpos__2_) in
let _sloc = (_symbolstartpos, _endpos) in
-# 2100 "parsing/parser.mly"
+# 2150 "parsing/parser.mly"
( mkexp_cons ~loc:_sloc _loc__2_ (ghexp ~loc:_sloc (Pexp_tuple[_1;_3])) )
-# 11304 "parsing/parser.ml"
+# 11237 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 : (Parsetree.expression) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 11339 "parsing/parser.ml"
+# 11272 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.expression) = let _1 =
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 11348 "parsing/parser.ml"
+# 11281 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 11356 "parsing/parser.ml"
+# 11289 "parsing/parser.ml"
in
let _endpos = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2102 "parsing/parser.mly"
+# 2152 "parsing/parser.mly"
( mkexp ~loc:_sloc (Pexp_setinstvar(_1, _3)) )
-# 11365 "parsing/parser.ml"
+# 11298 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 11423 "parsing/parser.ml"
+# 11356 "parsing/parser.ml"
in
let _endpos = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2104 "parsing/parser.mly"
+# 2154 "parsing/parser.mly"
( mkexp ~loc:_sloc (Pexp_setfield(_1, _3, _5)) )
-# 11432 "parsing/parser.ml"
+# 11365 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2106 "parsing/parser.mly"
+# 2156 "parsing/parser.mly"
( array_set ~loc:_sloc _1 _4 _7 )
-# 11502 "parsing/parser.ml"
+# 11435 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2108 "parsing/parser.mly"
+# 2158 "parsing/parser.mly"
( string_set ~loc:_sloc _1 _4 _7 )
-# 11572 "parsing/parser.ml"
+# 11505 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2110 "parsing/parser.mly"
+# 2160 "parsing/parser.mly"
( bigarray_set ~loc:_sloc _1 _4 _7 )
-# 11642 "parsing/parser.ml"
+# 11575 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _3 : unit = Obj.magic _3 in
let _2 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 11704 "parsing/parser.ml"
+# 11637 "parsing/parser.ml"
) = Obj.magic _2 in
let _1 : (Parsetree.expression) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : (Parsetree.expression) = let _4 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 11713 "parsing/parser.ml"
+# 11646 "parsing/parser.ml"
in
let _endpos = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2112 "parsing/parser.mly"
+# 2162 "parsing/parser.mly"
( dotop_set ~loc:_sloc lident bracket _2 _1 _4 _7 )
-# 11721 "parsing/parser.ml"
+# 11654 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _3 : unit = Obj.magic _3 in
let _2 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 11783 "parsing/parser.ml"
+# 11716 "parsing/parser.ml"
) = Obj.magic _2 in
let _1 : (Parsetree.expression) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : (Parsetree.expression) = let _4 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 11792 "parsing/parser.ml"
+# 11725 "parsing/parser.ml"
in
let _endpos = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2114 "parsing/parser.mly"
+# 2164 "parsing/parser.mly"
( dotop_set ~loc:_sloc lident paren _2 _1 _4 _7 )
-# 11800 "parsing/parser.ml"
+# 11733 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _3 : unit = Obj.magic _3 in
let _2 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 11862 "parsing/parser.ml"
+# 11795 "parsing/parser.ml"
) = Obj.magic _2 in
let _1 : (Parsetree.expression) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : (Parsetree.expression) = let _4 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 11871 "parsing/parser.ml"
+# 11804 "parsing/parser.ml"
in
let _endpos = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2116 "parsing/parser.mly"
+# 2166 "parsing/parser.mly"
( dotop_set ~loc:_sloc lident brace _2 _1 _4 _7 )
-# 11879 "parsing/parser.ml"
+# 11812 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _5 : unit = Obj.magic _5 in
let _4 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 11953 "parsing/parser.ml"
+# 11886 "parsing/parser.ml"
) = Obj.magic _4 in
let _3 : (Longident.t) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__9_ in
let _v : (Parsetree.expression) = let _6 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 11964 "parsing/parser.ml"
+# 11897 "parsing/parser.ml"
in
let _endpos = _endpos__9_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2119 "parsing/parser.mly"
+# 2169 "parsing/parser.mly"
( dotop_set ~loc:_sloc (ldot _3) bracket _4 _1 _6 _9 )
-# 11972 "parsing/parser.ml"
+# 11905 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _5 : unit = Obj.magic _5 in
let _4 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 12046 "parsing/parser.ml"
+# 11979 "parsing/parser.ml"
) = Obj.magic _4 in
let _3 : (Longident.t) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__9_ in
let _v : (Parsetree.expression) = let _6 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 12057 "parsing/parser.ml"
+# 11990 "parsing/parser.ml"
in
let _endpos = _endpos__9_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2122 "parsing/parser.mly"
+# 2172 "parsing/parser.mly"
( dotop_set ~loc:_sloc (ldot _3) paren _4 _1 _6 _9 )
-# 12065 "parsing/parser.ml"
+# 11998 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _5 : unit = Obj.magic _5 in
let _4 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 12139 "parsing/parser.ml"
+# 12072 "parsing/parser.ml"
) = Obj.magic _4 in
let _3 : (Longident.t) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__9_ in
let _v : (Parsetree.expression) = let _6 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 12150 "parsing/parser.ml"
+# 12083 "parsing/parser.ml"
in
let _endpos = _endpos__9_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2125 "parsing/parser.mly"
+# 2175 "parsing/parser.mly"
( dotop_set ~loc:_sloc (ldot _3) brace _4 _1 _6 _9 )
-# 12158 "parsing/parser.ml"
+# 12091 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.expression) =
-# 2127 "parsing/parser.mly"
+# 2177 "parsing/parser.mly"
( Exp.attr _1 _2 )
-# 12190 "parsing/parser.ml"
+# 12123 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.expression) = let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2129 "parsing/parser.mly"
+# 2179 "parsing/parser.mly"
( not_expecting _loc__1_ "wildcard \"_\"" )
-# 12216 "parsing/parser.ml"
+# 12149 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (string Asttypes.loc option) =
-# 3672 "parsing/parser.mly"
+# 3734 "parsing/parser.mly"
( None )
-# 12234 "parsing/parser.ml"
+# 12167 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (string Asttypes.loc option) =
-# 3673 "parsing/parser.mly"
+# 3735 "parsing/parser.mly"
( Some _2 )
-# 12266 "parsing/parser.ml"
+# 12199 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : (Parsetree.extension) =
-# 3683 "parsing/parser.mly"
- ( (_2, _3) )
-# 12312 "parsing/parser.ml"
+# 3745 "parsing/parser.mly"
+ ( (_2, _3) )
+# 12245 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ } = _menhir_stack in
+ let _1 : (
+# 687 "parsing/parser.mly"
+ (string * Location.t * string * Location.t * string option)
+# 12266 "parsing/parser.ml"
+ ) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_ in
+ let _v : (Parsetree.extension) = let _endpos = _endpos__1_ in
+ let _symbolstartpos = _startpos__1_ in
+ let _sloc = (_symbolstartpos, _endpos) in
+
+# 3747 "parsing/parser.mly"
+ ( mk_quotedext ~loc:_sloc _1 )
+# 12277 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in
let _1_inlined2 : (Longident.t) = Obj.magic _1_inlined2 in
let _3 : unit = Obj.magic _3 in
- let _1_inlined1 : (string) = Obj.magic _1_inlined1 in
+ let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in
let _1 : unit = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _v : (Parsetree.extension_constructor) = let attrs =
let _1 = _1_inlined3 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 12367 "parsing/parser.ml"
+# 12332 "parsing/parser.ml"
in
let _endpos_attrs_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 12379 "parsing/parser.ml"
+# 12344 "parsing/parser.ml"
in
let cid =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 12390 "parsing/parser.ml"
+# 12355 "parsing/parser.ml"
in
let _endpos = _endpos_attrs_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3053 "parsing/parser.mly"
+# 3103 "parsing/parser.mly"
( let info = symbol_info _endpos in
Te.rebind cid lid ~attrs ~loc:(make_loc _sloc) ~info )
-# 12400 "parsing/parser.ml"
+# 12365 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in
let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in
let _3 : unit = Obj.magic _3 in
- let _1 : (string) = Obj.magic _1 in
+ let _1 : (Asttypes.label) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_inlined2_ in
let _v : (Parsetree.extension_constructor) = let attrs =
let _1 = _1_inlined2 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 12448 "parsing/parser.ml"
+# 12413 "parsing/parser.ml"
in
let _endpos_attrs_ = _endpos__1_inlined2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 12460 "parsing/parser.ml"
+# 12425 "parsing/parser.ml"
in
let cid =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 12470 "parsing/parser.ml"
+# 12435 "parsing/parser.ml"
in
let _startpos_cid_ = _startpos__1_ in
let _1 =
-# 3492 "parsing/parser.mly"
+# 3554 "parsing/parser.mly"
( () )
-# 12477 "parsing/parser.ml"
+# 12442 "parsing/parser.ml"
in
let _endpos = _endpos_attrs_ in
let _symbolstartpos = _startpos_cid_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3053 "parsing/parser.mly"
+# 3103 "parsing/parser.mly"
( let info = symbol_info _endpos in
Te.rebind cid lid ~attrs ~loc:(make_loc _sloc) ~info )
-# 12486 "parsing/parser.ml"
+# 12451 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3660 "parsing/parser.mly"
+# 3722 "parsing/parser.mly"
( mark_symbol_docs _sloc;
Attr.mk ~loc:(make_loc _sloc) _2 _3 )
-# 12536 "parsing/parser.ml"
+# 12501 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : ((Parsetree.core_type * Asttypes.variance) list) = let params =
-# 1878 "parsing/parser.mly"
+# 1928 "parsing/parser.mly"
( [] )
-# 12554 "parsing/parser.ml"
+# 12519 "parsing/parser.ml"
in
-# 1703 "parsing/parser.mly"
+# 1753 "parsing/parser.mly"
( params )
-# 12559 "parsing/parser.ml"
+# 12524 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : ((Parsetree.core_type * Asttypes.variance) list) = let params =
let params =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 12600 "parsing/parser.ml"
+# 12565 "parsing/parser.ml"
in
-# 926 "parsing/parser.mly"
+# 947 "parsing/parser.mly"
( xs )
-# 12605 "parsing/parser.ml"
+# 12570 "parsing/parser.ml"
in
-# 1880 "parsing/parser.mly"
+# 1930 "parsing/parser.mly"
( params )
-# 12611 "parsing/parser.ml"
+# 12576 "parsing/parser.ml"
in
-# 1703 "parsing/parser.mly"
+# 1753 "parsing/parser.mly"
( params )
-# 12617 "parsing/parser.ml"
+# 12582 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.expression) =
-# 2455 "parsing/parser.mly"
+# 2505 "parsing/parser.mly"
( _1 )
-# 12642 "parsing/parser.ml"
+# 12607 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2457 "parsing/parser.mly"
+# 2507 "parsing/parser.mly"
( mkexp_constraint ~loc:_sloc _3 _1 )
-# 12684 "parsing/parser.ml"
+# 12649 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.expression) =
-# 2481 "parsing/parser.mly"
+# 2531 "parsing/parser.mly"
( _2 )
-# 12716 "parsing/parser.ml"
+# 12681 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__4_ in
let _v : (Parsetree.expression) = let _1 =
let _1 =
-# 2483 "parsing/parser.mly"
+# 2533 "parsing/parser.mly"
( Pexp_constraint (_4, _2) )
-# 12763 "parsing/parser.ml"
+# 12728 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__4_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 12772 "parsing/parser.ml"
+# 12737 "parsing/parser.ml"
in
-# 2484 "parsing/parser.mly"
+# 2534 "parsing/parser.mly"
( _1 )
-# 12778 "parsing/parser.ml"
+# 12743 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2487 "parsing/parser.mly"
+# 2537 "parsing/parser.mly"
(
let (l,o,p) = _1 in
ghexp ~loc:_sloc (Pexp_fun(l, o, p, _2))
)
-# 12816 "parsing/parser.ml"
+# 12781 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : (Parsetree.expression) = let _3 =
-# 2364 "parsing/parser.mly"
+# 2414 "parsing/parser.mly"
( xs )
-# 12869 "parsing/parser.ml"
+# 12834 "parsing/parser.ml"
in
let _endpos = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2492 "parsing/parser.mly"
+# 2542 "parsing/parser.mly"
( mk_newtypes ~loc:_sloc _3 _5 )
-# 12877 "parsing/parser.ml"
+# 12842 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_ty_ in
let _endpos = _endpos_ty_ in
let _v : (Parsetree.core_type) =
-# 3165 "parsing/parser.mly"
+# 3215 "parsing/parser.mly"
( ty )
-# 12902 "parsing/parser.ml"
+# 12867 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.core_type) = let _1 =
let _1 =
let domain =
-# 790 "parsing/parser.mly"
+# 811 "parsing/parser.mly"
( extra_rhs_core_type _1 ~pos:_endpos__1_ )
-# 12950 "parsing/parser.ml"
+# 12915 "parsing/parser.ml"
in
let label =
-# 3177 "parsing/parser.mly"
+# 3227 "parsing/parser.mly"
( Optional label )
-# 12955 "parsing/parser.ml"
+# 12920 "parsing/parser.ml"
in
-# 3171 "parsing/parser.mly"
+# 3221 "parsing/parser.mly"
( Ptyp_arrow(label, domain, codomain) )
-# 12960 "parsing/parser.ml"
+# 12925 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_label_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 12970 "parsing/parser.ml"
+# 12935 "parsing/parser.ml"
in
-# 3173 "parsing/parser.mly"
+# 3223 "parsing/parser.mly"
( _1 )
-# 12976 "parsing/parser.ml"
+# 12941 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 : (Parsetree.core_type) = Obj.magic _1 in
let _2 : unit = Obj.magic _2 in
let label : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 13025 "parsing/parser.ml"
+# 12990 "parsing/parser.ml"
) = Obj.magic label in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos_label_ in
let _v : (Parsetree.core_type) = let _1 =
let _1 =
let domain =
-# 790 "parsing/parser.mly"
+# 811 "parsing/parser.mly"
( extra_rhs_core_type _1 ~pos:_endpos__1_ )
-# 13035 "parsing/parser.ml"
+# 13000 "parsing/parser.ml"
in
let label =
-# 3179 "parsing/parser.mly"
+# 3229 "parsing/parser.mly"
( Labelled label )
-# 13040 "parsing/parser.ml"
+# 13005 "parsing/parser.ml"
in
-# 3171 "parsing/parser.mly"
+# 3221 "parsing/parser.mly"
( Ptyp_arrow(label, domain, codomain) )
-# 13045 "parsing/parser.ml"
+# 13010 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_label_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 13055 "parsing/parser.ml"
+# 13020 "parsing/parser.ml"
in
-# 3173 "parsing/parser.mly"
+# 3223 "parsing/parser.mly"
( _1 )
-# 13061 "parsing/parser.ml"
+# 13026 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.core_type) = let _1 =
let _1 =
let domain =
-# 790 "parsing/parser.mly"
+# 811 "parsing/parser.mly"
( extra_rhs_core_type _1 ~pos:_endpos__1_ )
-# 13102 "parsing/parser.ml"
+# 13067 "parsing/parser.ml"
in
let label =
-# 3181 "parsing/parser.mly"
+# 3231 "parsing/parser.mly"
( Nolabel )
-# 13107 "parsing/parser.ml"
+# 13072 "parsing/parser.ml"
in
-# 3171 "parsing/parser.mly"
+# 3221 "parsing/parser.mly"
( Ptyp_arrow(label, domain, codomain) )
-# 13112 "parsing/parser.ml"
+# 13077 "parsing/parser.ml"
in
let _endpos__1_ = _endpos_codomain_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 13122 "parsing/parser.ml"
+# 13087 "parsing/parser.ml"
in
-# 3173 "parsing/parser.mly"
+# 3223 "parsing/parser.mly"
( _1 )
-# 13128 "parsing/parser.ml"
+# 13093 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.functor_parameter) =
-# 1136 "parsing/parser.mly"
+# 1186 "parsing/parser.mly"
( Unit )
-# 13160 "parsing/parser.ml"
+# 13125 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 13218 "parsing/parser.ml"
+# 13183 "parsing/parser.ml"
in
-# 1139 "parsing/parser.mly"
+# 1189 "parsing/parser.mly"
( Named (x, mty) )
-# 13224 "parsing/parser.ml"
+# 13189 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.constructor_arguments * Parsetree.core_type option) =
-# 2973 "parsing/parser.mly"
+# 3023 "parsing/parser.mly"
( (Pcstr_tuple [],None) )
-# 13242 "parsing/parser.ml"
+# 13207 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.constructor_arguments * Parsetree.core_type option) =
-# 2974 "parsing/parser.mly"
+# 3024 "parsing/parser.mly"
( (_2,None) )
-# 13274 "parsing/parser.ml"
+# 13239 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : (Parsetree.constructor_arguments * Parsetree.core_type option) =
-# 2976 "parsing/parser.mly"
+# 3026 "parsing/parser.mly"
( (_2,Some _4) )
-# 13320 "parsing/parser.ml"
+# 13285 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.constructor_arguments * Parsetree.core_type option) =
-# 2978 "parsing/parser.mly"
+# 3028 "parsing/parser.mly"
( (Pcstr_tuple [],Some _2) )
-# 13352 "parsing/parser.ml"
+# 13317 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in
let args_res : (Parsetree.constructor_arguments * Parsetree.core_type option) = Obj.magic args_res in
- let _1_inlined1 : (string) = Obj.magic _1_inlined1 in
+ let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in
let _1 : unit = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
Docstrings.info) = let attrs =
let _1 = _1_inlined2 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 13402 "parsing/parser.ml"
+# 13367 "parsing/parser.ml"
in
let _endpos_attrs_ = _endpos__1_inlined2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 13414 "parsing/parser.ml"
+# 13379 "parsing/parser.ml"
in
let _endpos = _endpos_attrs_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2921 "parsing/parser.mly"
+# 2971 "parsing/parser.mly"
(
let args, res = args_res in
let info = symbol_info _endpos in
let loc = make_loc _sloc in
cid, args, res, attrs, loc, info
)
-# 13428 "parsing/parser.ml"
+# 13393 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
let args_res : (Parsetree.constructor_arguments * Parsetree.core_type option) = Obj.magic args_res in
- let _1 : (string) = Obj.magic _1 in
+ let _1 : (Asttypes.label) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_inlined1_ in
Docstrings.info) = let attrs =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 13471 "parsing/parser.ml"
+# 13436 "parsing/parser.ml"
in
let _endpos_attrs_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 13482 "parsing/parser.ml"
+# 13447 "parsing/parser.ml"
in
let _startpos_cid_ = _startpos__1_ in
let _1 =
-# 3492 "parsing/parser.mly"
+# 3554 "parsing/parser.mly"
( () )
-# 13489 "parsing/parser.ml"
+# 13454 "parsing/parser.ml"
in
let _endpos = _endpos_attrs_ in
let _symbolstartpos = _startpos_cid_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2921 "parsing/parser.mly"
+# 2971 "parsing/parser.mly"
(
let args, res = args_res in
let info = symbol_info _endpos in
let loc = make_loc _sloc in
cid, args, res, attrs, loc, info
)
-# 13502 "parsing/parser.ml"
+# 13467 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic _2 in
let _1_inlined3 : unit = Obj.magic _1_inlined3 in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 13575 "parsing/parser.ml"
+# 13540 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
Parsetree.type_declaration) = let attrs2 =
let _1 = _1_inlined4 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 13590 "parsing/parser.ml"
+# 13555 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined4_ in
let cstrs =
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 13599 "parsing/parser.ml"
+# 13564 "parsing/parser.ml"
in
-# 876 "parsing/parser.mly"
+# 897 "parsing/parser.mly"
( xs )
-# 13604 "parsing/parser.ml"
+# 13569 "parsing/parser.ml"
in
-# 2837 "parsing/parser.mly"
+# 2887 "parsing/parser.mly"
( _1 )
-# 13610 "parsing/parser.ml"
+# 13575 "parsing/parser.ml"
in
let kind_priv_manifest =
let _1 = _1_inlined3 in
-# 2872 "parsing/parser.mly"
+# 2922 "parsing/parser.mly"
( _2 )
-# 13618 "parsing/parser.ml"
+# 13583 "parsing/parser.ml"
in
let id =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 13629 "parsing/parser.ml"
+# 13594 "parsing/parser.ml"
in
let flag =
-# 3512 "parsing/parser.mly"
+# 3574 "parsing/parser.mly"
( Recursive )
-# 13635 "parsing/parser.ml"
+# 13600 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 13642 "parsing/parser.ml"
+# 13607 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2809 "parsing/parser.mly"
+# 2859 "parsing/parser.mly"
(
let (kind, priv, manifest) = kind_priv_manifest in
let docs = symbol_docs _sloc in
(flag, ext),
Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs
)
-# 13658 "parsing/parser.ml"
+# 13623 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic _2 in
let _1_inlined4 : unit = Obj.magic _1_inlined4 in
let _1_inlined3 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 13737 "parsing/parser.ml"
+# 13702 "parsing/parser.ml"
) = Obj.magic _1_inlined3 in
let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in
let _1_inlined2 : unit = Obj.magic _1_inlined2 in
Parsetree.type_declaration) = let attrs2 =
let _1 = _1_inlined5 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 13753 "parsing/parser.ml"
+# 13718 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined5_ in
let cstrs =
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 13762 "parsing/parser.ml"
+# 13727 "parsing/parser.ml"
in
-# 876 "parsing/parser.mly"
+# 897 "parsing/parser.mly"
( xs )
-# 13767 "parsing/parser.ml"
+# 13732 "parsing/parser.ml"
in
-# 2837 "parsing/parser.mly"
+# 2887 "parsing/parser.mly"
( _1 )
-# 13773 "parsing/parser.ml"
+# 13738 "parsing/parser.ml"
in
let kind_priv_manifest =
let _1 = _1_inlined4 in
-# 2872 "parsing/parser.mly"
+# 2922 "parsing/parser.mly"
( _2 )
-# 13781 "parsing/parser.ml"
+# 13746 "parsing/parser.ml"
in
let id =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 13792 "parsing/parser.ml"
+# 13757 "parsing/parser.ml"
in
let flag =
let _startpos = _startpos__1_ in
let _loc = (_startpos, _endpos) in
-# 3513 "parsing/parser.mly"
+# 3575 "parsing/parser.mly"
( not_expecting _loc "nonrec flag" )
-# 13803 "parsing/parser.ml"
+# 13768 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 13811 "parsing/parser.ml"
+# 13776 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2809 "parsing/parser.mly"
+# 2859 "parsing/parser.mly"
(
let (kind, priv, manifest) = kind_priv_manifest in
let docs = symbol_docs _sloc in
(flag, ext),
Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs
)
-# 13827 "parsing/parser.ml"
+# 13792 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let xs : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) list) = Obj.magic xs in
let kind_priv_manifest : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic kind_priv_manifest in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 13893 "parsing/parser.ml"
+# 13858 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
Parsetree.type_declaration) = let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 13908 "parsing/parser.ml"
+# 13873 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let cstrs =
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 13917 "parsing/parser.ml"
+# 13882 "parsing/parser.ml"
in
-# 876 "parsing/parser.mly"
+# 897 "parsing/parser.mly"
( xs )
-# 13922 "parsing/parser.ml"
+# 13887 "parsing/parser.ml"
in
-# 2837 "parsing/parser.mly"
+# 2887 "parsing/parser.mly"
( _1 )
-# 13928 "parsing/parser.ml"
+# 13893 "parsing/parser.ml"
in
let id =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 13939 "parsing/parser.ml"
+# 13904 "parsing/parser.ml"
in
let flag =
-# 3508 "parsing/parser.mly"
+# 3570 "parsing/parser.mly"
( Recursive )
-# 13945 "parsing/parser.ml"
+# 13910 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 13952 "parsing/parser.ml"
+# 13917 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2809 "parsing/parser.mly"
+# 2859 "parsing/parser.mly"
(
let (kind, priv, manifest) = kind_priv_manifest in
let docs = symbol_docs _sloc in
(flag, ext),
Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs
)
-# 13968 "parsing/parser.ml"
+# 13933 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let xs : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) list) = Obj.magic xs in
let kind_priv_manifest : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic kind_priv_manifest in
let _1_inlined3 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 14040 "parsing/parser.ml"
+# 14005 "parsing/parser.ml"
) = Obj.magic _1_inlined3 in
let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in
let _1_inlined2 : unit = Obj.magic _1_inlined2 in
Parsetree.type_declaration) = let attrs2 =
let _1 = _1_inlined4 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 14056 "parsing/parser.ml"
+# 14021 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined4_ in
let cstrs =
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 14065 "parsing/parser.ml"
+# 14030 "parsing/parser.ml"
in
-# 876 "parsing/parser.mly"
+# 897 "parsing/parser.mly"
( xs )
-# 14070 "parsing/parser.ml"
+# 14035 "parsing/parser.ml"
in
-# 2837 "parsing/parser.mly"
+# 2887 "parsing/parser.mly"
( _1 )
-# 14076 "parsing/parser.ml"
+# 14041 "parsing/parser.ml"
in
let id =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 14087 "parsing/parser.ml"
+# 14052 "parsing/parser.ml"
in
let flag =
let _1 = _1_inlined2 in
-# 3509 "parsing/parser.mly"
+# 3571 "parsing/parser.mly"
( Nonrecursive )
-# 14095 "parsing/parser.ml"
+# 14060 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 14103 "parsing/parser.ml"
+# 14068 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2809 "parsing/parser.mly"
+# 2859 "parsing/parser.mly"
(
let (kind, priv, manifest) = kind_priv_manifest in
let docs = symbol_docs _sloc in
(flag, ext),
Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs
)
-# 14119 "parsing/parser.ml"
+# 14084 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 688 "parsing/parser.mly"
+# 697 "parsing/parser.mly"
(string)
-# 14140 "parsing/parser.ml"
+# 14105 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.label) =
-# 3365 "parsing/parser.mly"
+# 3415 "parsing/parser.mly"
( _1 )
-# 14148 "parsing/parser.ml"
+# 14113 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 14169 "parsing/parser.ml"
+# 14134 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.label) =
-# 3366 "parsing/parser.mly"
+# 3416 "parsing/parser.mly"
( _1 )
-# 14177 "parsing/parser.ml"
+# 14142 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (
-# 768 "parsing/parser.mly"
+# 777 "parsing/parser.mly"
(Parsetree.structure)
-# 14209 "parsing/parser.ml"
+# 14174 "parsing/parser.ml"
) =
-# 1047 "parsing/parser.mly"
+# 1068 "parsing/parser.mly"
( _1 )
-# 14213 "parsing/parser.ml"
+# 14178 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (string) =
-# 3412 "parsing/parser.mly"
+# 3465 "parsing/parser.mly"
( "" )
-# 14231 "parsing/parser.ml"
+# 14196 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (string) =
-# 3413 "parsing/parser.mly"
+# 3466 "parsing/parser.mly"
( ";.." )
-# 14263 "parsing/parser.ml"
+# 14228 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (
-# 770 "parsing/parser.mly"
+# 779 "parsing/parser.mly"
(Parsetree.signature)
-# 14295 "parsing/parser.ml"
+# 14260 "parsing/parser.ml"
) =
-# 1053 "parsing/parser.mly"
+# 1074 "parsing/parser.mly"
( _1 )
-# 14299 "parsing/parser.ml"
+# 14264 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : (Parsetree.extension) =
-# 3686 "parsing/parser.mly"
- ( (_2, _3) )
-# 14345 "parsing/parser.ml"
+# 3750 "parsing/parser.mly"
+ ( (_2, _3) )
+# 14310 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ } = _menhir_stack in
+ let _1 : (
+# 689 "parsing/parser.mly"
+ (string * Location.t * string * Location.t * string option)
+# 14331 "parsing/parser.ml"
+ ) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_ in
+ let _v : (Parsetree.extension) = let _endpos = _endpos__1_ in
+ let _symbolstartpos = _startpos__1_ in
+ let _sloc = (_symbolstartpos, _endpos) in
+
+# 3752 "parsing/parser.mly"
+ ( mk_quotedext ~loc:_sloc _1 )
+# 14342 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined2 : (Parsetree.core_type) = Obj.magic _1_inlined2 in
let _3 : unit = Obj.magic _3 in
let _1_inlined1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 14393 "parsing/parser.ml"
+# 14390 "parsing/parser.ml"
) = Obj.magic _1_inlined1 in
let _1 : (Asttypes.mutable_flag) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _v : (Parsetree.label_declaration) = let _5 =
let _1 = _1_inlined3 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 14404 "parsing/parser.ml"
+# 14401 "parsing/parser.ml"
in
let _endpos__5_ = _endpos__1_inlined3_ in
let _4 =
let _1 = _1_inlined2 in
-# 3118 "parsing/parser.mly"
+# 3168 "parsing/parser.mly"
( _1 )
-# 14413 "parsing/parser.ml"
+# 14410 "parsing/parser.ml"
in
let _2 =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 14421 "parsing/parser.ml"
+# 14418 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 14429 "parsing/parser.ml"
+# 14426 "parsing/parser.ml"
in
let _startpos__2_ = _startpos__1_inlined1_ in
_startpos__2_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2995 "parsing/parser.mly"
+# 3045 "parsing/parser.mly"
( let info = symbol_info _endpos in
Type.field _2 _4 ~mut:_1 ~attrs:_5 ~loc:(make_loc _sloc) ~info )
-# 14443 "parsing/parser.ml"
+# 14440 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined2 : (Parsetree.core_type) = Obj.magic _1_inlined2 in
let _3 : unit = Obj.magic _3 in
let _1_inlined1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 14505 "parsing/parser.ml"
+# 14502 "parsing/parser.ml"
) = Obj.magic _1_inlined1 in
let _1 : (Asttypes.mutable_flag) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _v : (Parsetree.label_declaration) = let _7 =
let _1 = _1_inlined4 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 14516 "parsing/parser.ml"
+# 14513 "parsing/parser.ml"
in
let _endpos__7_ = _endpos__1_inlined4_ in
let _5 =
let _1 = _1_inlined3 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 14525 "parsing/parser.ml"
+# 14522 "parsing/parser.ml"
in
let _endpos__5_ = _endpos__1_inlined3_ in
let _4 =
let _1 = _1_inlined2 in
-# 3118 "parsing/parser.mly"
+# 3168 "parsing/parser.mly"
( _1 )
-# 14534 "parsing/parser.ml"
+# 14531 "parsing/parser.ml"
in
let _2 =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 14542 "parsing/parser.ml"
+# 14539 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 14550 "parsing/parser.ml"
+# 14547 "parsing/parser.ml"
in
let _startpos__2_ = _startpos__1_inlined1_ in
_startpos__2_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3000 "parsing/parser.mly"
+# 3050 "parsing/parser.mly"
( let info =
match rhs_info _endpos__5_ with
| Some _ as info_before_semi -> info_before_semi
| None -> symbol_info _endpos
in
Type.field _2 _4 ~mut:_1 ~attrs:(_5 @ _7) ~loc:(make_loc _sloc) ~info )
-# 14568 "parsing/parser.ml"
+# 14565 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.label_declaration list) =
-# 2989 "parsing/parser.mly"
+# 3039 "parsing/parser.mly"
( [_1] )
-# 14593 "parsing/parser.ml"
+# 14590 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.label_declaration list) =
-# 2990 "parsing/parser.mly"
+# 3040 "parsing/parser.mly"
( [_1] )
-# 14618 "parsing/parser.ml"
+# 14615 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.label_declaration list) =
-# 2991 "parsing/parser.mly"
+# 3041 "parsing/parser.mly"
( _1 :: _2 )
-# 14650 "parsing/parser.ml"
+# 14647 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 14671 "parsing/parser.ml"
+# 14668 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 14684 "parsing/parser.ml"
+# 14681 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2073 "parsing/parser.mly"
+# 2123 "parsing/parser.mly"
( (_1.Location.txt, mkpat ~loc:_sloc (Ppat_var _1)) )
-# 14693 "parsing/parser.ml"
+# 14690 "parsing/parser.ml"
in
-# 2065 "parsing/parser.mly"
+# 2115 "parsing/parser.mly"
( x )
-# 14699 "parsing/parser.ml"
+# 14696 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let cty : (Parsetree.core_type) = Obj.magic cty in
let _2 : unit = Obj.magic _2 in
let _1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 14734 "parsing/parser.ml"
+# 14731 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 14747 "parsing/parser.ml"
+# 14744 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2073 "parsing/parser.mly"
+# 2123 "parsing/parser.mly"
( (_1.Location.txt, mkpat ~loc:_sloc (Ppat_var _1)) )
-# 14756 "parsing/parser.ml"
+# 14753 "parsing/parser.ml"
in
let _startpos_x_ = _startpos__1_ in
let _symbolstartpos = _startpos_x_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2067 "parsing/parser.mly"
+# 2117 "parsing/parser.mly"
( let lab, pat = x in
lab,
mkpat ~loc:_sloc (Ppat_constraint (pat, cty)) )
-# 14768 "parsing/parser.ml"
+# 14765 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.endp = _endpos__1_;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
- let _1 : (
-# 642 "parsing/parser.mly"
- (string)
-# 14789 "parsing/parser.ml"
- ) = Obj.magic _1 in
- let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
- let _startpos = _startpos__1_ in
- let _endpos = _endpos__1_ in
- let _v : (Longident.t) =
-# 3438 "parsing/parser.mly"
- ( Lident _1 )
-# 14797 "parsing/parser.ml"
- in
- {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = Obj.repr _v;
- MenhirLib.EngineTypes.startp = _startpos;
- MenhirLib.EngineTypes.endp = _endpos;
- MenhirLib.EngineTypes.next = _menhir_stack;
- });
- (fun _menhir_env ->
- let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
- let {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _3;
- MenhirLib.EngineTypes.startp = _startpos__3_;
- MenhirLib.EngineTypes.endp = _endpos__3_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _2;
- MenhirLib.EngineTypes.startp = _startpos__2_;
- MenhirLib.EngineTypes.endp = _endpos__2_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = _1;
- MenhirLib.EngineTypes.startp = _startpos__1_;
- MenhirLib.EngineTypes.endp = _endpos__1_;
- MenhirLib.EngineTypes.next = _menhir_stack;
- };
- };
- } = _menhir_stack in
- let _3 : (
-# 642 "parsing/parser.mly"
- (string)
-# 14830 "parsing/parser.ml"
- ) = Obj.magic _3 in
- let _2 : unit = Obj.magic _2 in
let _1 : (Longident.t) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
- let _endpos = _endpos__3_ in
+ let _endpos = _endpos__1_ in
let _v : (Longident.t) =
-# 3439 "parsing/parser.mly"
- ( Ldot(_1, _3) )
-# 14840 "parsing/parser.ml"
+# 3497 "parsing/parser.mly"
+ ( _1 )
+# 14790 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.arg_label * Parsetree.expression) =
-# 2350 "parsing/parser.mly"
+# 2400 "parsing/parser.mly"
( (Nolabel, _1) )
-# 14865 "parsing/parser.ml"
+# 14815 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : (Parsetree.expression) = Obj.magic _2 in
let _1 : (
-# 629 "parsing/parser.mly"
+# 634 "parsing/parser.mly"
(string)
-# 14893 "parsing/parser.ml"
+# 14843 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Asttypes.arg_label * Parsetree.expression) =
-# 2352 "parsing/parser.mly"
+# 2402 "parsing/parser.mly"
( (Labelled _1, _2) )
-# 14901 "parsing/parser.ml"
+# 14851 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let label : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 14928 "parsing/parser.ml"
+# 14878 "parsing/parser.ml"
) = Obj.magic label in
let _1 : unit = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _endpos_label_ in
let _v : (Asttypes.arg_label * Parsetree.expression) = let _loc_label_ = (_startpos_label_, _endpos_label_) in
-# 2354 "parsing/parser.mly"
+# 2404 "parsing/parser.mly"
( let loc = _loc_label_ in
(Labelled label, mkexpvar ~loc label) )
-# 14939 "parsing/parser.ml"
+# 14889 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let label : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 14966 "parsing/parser.ml"
+# 14916 "parsing/parser.ml"
) = Obj.magic label in
let _1 : unit = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _endpos_label_ in
let _v : (Asttypes.arg_label * Parsetree.expression) = let _loc_label_ = (_startpos_label_, _endpos_label_) in
-# 2357 "parsing/parser.mly"
+# 2407 "parsing/parser.mly"
( let loc = _loc_label_ in
(Optional label, mkexpvar ~loc label) )
-# 14977 "parsing/parser.ml"
+# 14927 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : (Parsetree.expression) = Obj.magic _2 in
let _1 : (
-# 659 "parsing/parser.mly"
+# 664 "parsing/parser.mly"
(string)
-# 15005 "parsing/parser.ml"
+# 14955 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Asttypes.arg_label * Parsetree.expression) =
-# 2360 "parsing/parser.mly"
+# 2410 "parsing/parser.mly"
( (Optional _1, _2) )
-# 15013 "parsing/parser.ml"
+# 14963 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = let _4 =
let _1 = _1_inlined1 in
-# 2061 "parsing/parser.mly"
+# 2111 "parsing/parser.mly"
( _1 )
-# 15068 "parsing/parser.ml"
+# 15018 "parsing/parser.ml"
in
-# 2035 "parsing/parser.mly"
+# 2085 "parsing/parser.mly"
( (Optional (fst _3), _4, snd _3) )
-# 15074 "parsing/parser.ml"
+# 15024 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _1_inlined1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 15101 "parsing/parser.ml"
+# 15051 "parsing/parser.ml"
) = Obj.magic _1_inlined1 in
let _1 : unit = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 15116 "parsing/parser.ml"
+# 15066 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2073 "parsing/parser.mly"
+# 2123 "parsing/parser.mly"
( (_1.Location.txt, mkpat ~loc:_sloc (Ppat_var _1)) )
-# 15125 "parsing/parser.ml"
+# 15075 "parsing/parser.ml"
in
-# 2037 "parsing/parser.mly"
+# 2087 "parsing/parser.mly"
( (Optional (fst _2), None, snd _2) )
-# 15131 "parsing/parser.ml"
+# 15081 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 : (Parsetree.pattern) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _1 : (
-# 659 "parsing/parser.mly"
+# 664 "parsing/parser.mly"
(string)
-# 15180 "parsing/parser.ml"
+# 15130 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = let _4 =
let _1 = _1_inlined1 in
-# 2061 "parsing/parser.mly"
+# 2111 "parsing/parser.mly"
( _1 )
-# 15190 "parsing/parser.ml"
+# 15140 "parsing/parser.ml"
in
-# 2039 "parsing/parser.mly"
+# 2089 "parsing/parser.mly"
( (Optional _1, _4, _3) )
-# 15196 "parsing/parser.ml"
+# 15146 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : (Parsetree.pattern) = Obj.magic _2 in
let _1 : (
-# 659 "parsing/parser.mly"
+# 664 "parsing/parser.mly"
(string)
-# 15224 "parsing/parser.ml"
+# 15174 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) =
-# 2041 "parsing/parser.mly"
+# 2091 "parsing/parser.mly"
( (Optional _1, None, _2) )
-# 15232 "parsing/parser.ml"
+# 15182 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) =
-# 2043 "parsing/parser.mly"
+# 2093 "parsing/parser.mly"
( (Labelled (fst _3), None, snd _3) )
-# 15278 "parsing/parser.ml"
+# 15228 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _1_inlined1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 15305 "parsing/parser.ml"
+# 15255 "parsing/parser.ml"
) = Obj.magic _1_inlined1 in
let _1 : unit = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 15320 "parsing/parser.ml"
+# 15270 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2073 "parsing/parser.mly"
+# 2123 "parsing/parser.mly"
( (_1.Location.txt, mkpat ~loc:_sloc (Ppat_var _1)) )
-# 15329 "parsing/parser.ml"
+# 15279 "parsing/parser.ml"
in
-# 2045 "parsing/parser.mly"
+# 2095 "parsing/parser.mly"
( (Labelled (fst _2), None, snd _2) )
-# 15335 "parsing/parser.ml"
+# 15285 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : (Parsetree.pattern) = Obj.magic _2 in
let _1 : (
-# 629 "parsing/parser.mly"
+# 634 "parsing/parser.mly"
(string)
-# 15363 "parsing/parser.ml"
+# 15313 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) =
-# 2047 "parsing/parser.mly"
+# 2097 "parsing/parser.mly"
( (Labelled _1, None, _2) )
-# 15371 "parsing/parser.ml"
+# 15321 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) =
-# 2049 "parsing/parser.mly"
+# 2099 "parsing/parser.mly"
( (Nolabel, None, _1) )
-# 15396 "parsing/parser.ml"
+# 15346 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (Parsetree.expression) = Obj.magic _2 in
- let _1 : (string) = Obj.magic _1 in
+ let _1 : (Asttypes.label) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2367 "parsing/parser.mly"
+# 2417 "parsing/parser.mly"
( mkpatvar ~loc:_sloc _1 )
-# 15432 "parsing/parser.ml"
+# 15382 "parsing/parser.ml"
in
-# 2371 "parsing/parser.mly"
+# 2421 "parsing/parser.mly"
( (_1, _2) )
-# 15438 "parsing/parser.ml"
+# 15388 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _4 : (Parsetree.expression) = Obj.magic _4 in
let _3 : unit = Obj.magic _3 in
let _2 : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic _2 in
- let _1 : (string) = Obj.magic _1 in
+ let _1 : (Asttypes.label) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2367 "parsing/parser.mly"
+# 2417 "parsing/parser.mly"
( mkpatvar ~loc:_sloc _1 )
-# 15488 "parsing/parser.ml"
+# 15438 "parsing/parser.ml"
in
let _endpos = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2373 "parsing/parser.mly"
+# 2423 "parsing/parser.mly"
( let v = _1 in (* PR#7344 *)
let t =
match _2 with
let patloc = (_startpos__1_, _endpos__2_) in
(ghpat ~loc:patloc (Ppat_constraint(v, typ)),
mkexp_constraint ~loc:_sloc _4 _2) )
-# 15508 "parsing/parser.ml"
+# 15458 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _4 : unit = Obj.magic _4 in
let xs : (Asttypes.label Asttypes.loc list) = Obj.magic xs in
let _2 : unit = Obj.magic _2 in
- let _1 : (string) = Obj.magic _1 in
+ let _1 : (Asttypes.label) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : (Parsetree.pattern * Parsetree.expression) = let _3 =
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 15577 "parsing/parser.ml"
+# 15527 "parsing/parser.ml"
in
-# 894 "parsing/parser.mly"
+# 915 "parsing/parser.mly"
( xs )
-# 15582 "parsing/parser.ml"
+# 15532 "parsing/parser.ml"
in
-# 3100 "parsing/parser.mly"
+# 3150 "parsing/parser.mly"
( _1 )
-# 15588 "parsing/parser.ml"
+# 15538 "parsing/parser.ml"
in
let _startpos__3_ = _startpos_xs_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2367 "parsing/parser.mly"
+# 2417 "parsing/parser.mly"
( mkpatvar ~loc:_sloc _1 )
-# 15599 "parsing/parser.ml"
+# 15549 "parsing/parser.ml"
in
-# 2389 "parsing/parser.mly"
+# 2439 "parsing/parser.mly"
( let typloc = (_startpos__3_, _endpos__5_) in
let patloc = (_startpos__1_, _endpos__5_) in
(ghpat ~loc:patloc
(Ppat_constraint(_1, ghtyp ~loc:typloc (Ptyp_poly(_3,_5)))),
_7) )
-# 15609 "parsing/parser.ml"
+# 15559 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let xs : (string Asttypes.loc list) = Obj.magic xs in
let _3 : unit = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
- let _1 : (string) = Obj.magic _1 in
+ let _1 : (Asttypes.label) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__8_ in
let _v : (Parsetree.pattern * Parsetree.expression) = let _4 =
-# 2364 "parsing/parser.mly"
+# 2414 "parsing/parser.mly"
( xs )
-# 15683 "parsing/parser.ml"
+# 15633 "parsing/parser.ml"
in
let _1 =
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2367 "parsing/parser.mly"
+# 2417 "parsing/parser.mly"
( mkpatvar ~loc:_sloc _1 )
-# 15692 "parsing/parser.ml"
+# 15642 "parsing/parser.ml"
in
let _endpos = _endpos__8_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2395 "parsing/parser.mly"
+# 2445 "parsing/parser.mly"
( let exp, poly =
wrap_type_annotation ~loc:_sloc _4 _6 _8 in
let loc = (_startpos__1_, _endpos__6_) in
(ghpat ~loc (Ppat_constraint(_1, poly)), exp) )
-# 15704 "parsing/parser.ml"
+# 15654 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.pattern * Parsetree.expression) =
-# 2400 "parsing/parser.mly"
+# 2450 "parsing/parser.mly"
( (_1, _3) )
-# 15743 "parsing/parser.ml"
+# 15693 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : (Parsetree.pattern * Parsetree.expression) =
-# 2402 "parsing/parser.mly"
+# 2452 "parsing/parser.mly"
( let loc = (_startpos__1_, _endpos__3_) in
(ghpat ~loc (Ppat_constraint(_1, _3)), _5) )
-# 15797 "parsing/parser.ml"
+# 15747 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs2 =
let _1 = _1_inlined2 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 15860 "parsing/parser.ml"
+# 15810 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined2_ in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 15869 "parsing/parser.ml"
+# 15819 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2418 "parsing/parser.mly"
+# 2468 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
mklbs ~loc:_sloc ext rec_flag (mklb ~loc:_sloc true body attrs)
)
-# 15881 "parsing/parser.ml"
+# 15831 "parsing/parser.ml"
in
-# 2408 "parsing/parser.mly"
+# 2458 "parsing/parser.mly"
( _1 )
-# 15887 "parsing/parser.ml"
+# 15837 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (let_bindings) =
-# 2409 "parsing/parser.mly"
+# 2459 "parsing/parser.mly"
( addlb _1 _2 )
-# 15919 "parsing/parser.ml"
+# 15869 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs2 =
let _1 = _1_inlined2 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 15975 "parsing/parser.ml"
+# 15925 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined2_ in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 15984 "parsing/parser.ml"
+# 15934 "parsing/parser.ml"
in
let ext =
-# 3676 "parsing/parser.mly"
+# 3738 "parsing/parser.mly"
( None )
-# 15990 "parsing/parser.ml"
+# 15940 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2418 "parsing/parser.mly"
+# 2468 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
mklbs ~loc:_sloc ext rec_flag (mklb ~loc:_sloc true body attrs)
)
-# 16001 "parsing/parser.ml"
+# 15951 "parsing/parser.ml"
in
-# 2408 "parsing/parser.mly"
+# 2458 "parsing/parser.mly"
( _1 )
-# 16007 "parsing/parser.ml"
+# 15957 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 16077 "parsing/parser.ml"
+# 16027 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let attrs1 =
let _1 = _1_inlined2 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 16086 "parsing/parser.ml"
+# 16036 "parsing/parser.ml"
in
let ext =
let _startpos = _startpos__1_ in
let _loc = (_startpos, _endpos) in
-# 3677 "parsing/parser.mly"
+# 3739 "parsing/parser.mly"
( not_expecting _loc "extension" )
-# 16097 "parsing/parser.ml"
+# 16047 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2418 "parsing/parser.mly"
+# 2468 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
mklbs ~loc:_sloc ext rec_flag (mklb ~loc:_sloc true body attrs)
)
-# 16109 "parsing/parser.ml"
+# 16059 "parsing/parser.ml"
in
-# 2408 "parsing/parser.mly"
+# 2458 "parsing/parser.mly"
( _1 )
-# 16115 "parsing/parser.ml"
+# 16065 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (let_bindings) =
-# 2409 "parsing/parser.mly"
+# 2459 "parsing/parser.mly"
( addlb _1 _2 )
-# 16147 "parsing/parser.ml"
+# 16097 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.pattern) =
-# 2077 "parsing/parser.mly"
+# 2127 "parsing/parser.mly"
( _1 )
-# 16172 "parsing/parser.ml"
+# 16122 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__3_ in
let _v : (Parsetree.pattern) = let _1 =
let _1 =
-# 2079 "parsing/parser.mly"
+# 2129 "parsing/parser.mly"
( Ppat_constraint(_1, _3) )
-# 16212 "parsing/parser.ml"
+# 16162 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 16221 "parsing/parser.ml"
+# 16171 "parsing/parser.ml"
in
-# 2080 "parsing/parser.mly"
+# 2130 "parsing/parser.mly"
( _1 )
-# 16227 "parsing/parser.ml"
+# 16177 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let exp : (Parsetree.expression) = Obj.magic exp in
- let _1 : (string) = Obj.magic _1 in
+ let _1 : (Asttypes.label) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos_exp_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2367 "parsing/parser.mly"
+# 2417 "parsing/parser.mly"
( mkpatvar ~loc:_sloc _1 )
-# 16263 "parsing/parser.ml"
+# 16213 "parsing/parser.ml"
in
-# 2435 "parsing/parser.mly"
+# 2485 "parsing/parser.mly"
( (pat, exp) )
-# 16269 "parsing/parser.ml"
+# 16219 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_pat_ in
let _endpos = _endpos_exp_ in
let _v : (Parsetree.pattern * Parsetree.expression) =
-# 2437 "parsing/parser.mly"
+# 2487 "parsing/parser.mly"
( let loc = (_startpos_pat_, _endpos_typ_) in
(ghpat ~loc (Ppat_constraint(pat, typ)), exp) )
-# 16323 "parsing/parser.ml"
+# 16273 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_pat_ in
let _endpos = _endpos_exp_ in
let _v : (Parsetree.pattern * Parsetree.expression) =
-# 2440 "parsing/parser.mly"
+# 2490 "parsing/parser.mly"
( (pat, exp) )
-# 16362 "parsing/parser.ml"
+# 16312 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_body_ in
let _endpos = _endpos_body_ in
let _v : (Parsetree.pattern * Parsetree.expression * Parsetree.binding_op list) =
-# 2444 "parsing/parser.mly"
+# 2494 "parsing/parser.mly"
( let let_pat, let_exp = body in
let_pat, let_exp, [] )
-# 16388 "parsing/parser.ml"
+# 16338 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let body : (Parsetree.pattern * Parsetree.expression) = Obj.magic body in
let _1 : (
-# 625 "parsing/parser.mly"
+# 630 "parsing/parser.mly"
(string)
-# 16422 "parsing/parser.ml"
+# 16372 "parsing/parser.ml"
) = Obj.magic _1 in
let bindings : (Parsetree.pattern * Parsetree.expression * Parsetree.binding_op list) = Obj.magic bindings in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 16435 "parsing/parser.ml"
+# 16385 "parsing/parser.ml"
in
let _endpos = _endpos_body_ in
let _symbolstartpos = _startpos_bindings_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2447 "parsing/parser.mly"
+# 2497 "parsing/parser.mly"
( let let_pat, let_exp, rev_ands = bindings in
let pbop_pat, pbop_exp = body in
let pbop_loc = make_loc _sloc in
let and_ = {pbop_op; pbop_pat; pbop_exp; pbop_loc} in
let_pat, let_exp, and_ :: rev_ands )
-# 16448 "parsing/parser.ml"
+# 16398 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.class_declaration list) =
-# 211 "menhir/standard.mly"
+# 211 "<standard.mly>"
( [] )
-# 16466 "parsing/parser.ml"
+# 16416 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in
let body : (Parsetree.class_expr) = Obj.magic body in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 16532 "parsing/parser.ml"
+# 16482 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in
let virt : (Asttypes.virtual_flag) = Obj.magic virt in
let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 16547 "parsing/parser.ml"
+# 16497 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 16559 "parsing/parser.ml"
+# 16509 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 16567 "parsing/parser.ml"
+# 16517 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1681 "parsing/parser.mly"
+# 1731 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
let text = symbol_text _symbolstartpos in
Ci.mk id body ~virt ~params ~attrs ~loc ~text ~docs
)
-# 16582 "parsing/parser.ml"
+# 16532 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 16588 "parsing/parser.ml"
+# 16538 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.class_description list) =
-# 211 "menhir/standard.mly"
+# 211 "<standard.mly>"
( [] )
-# 16606 "parsing/parser.ml"
+# 16556 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let cty : (Parsetree.class_type) = Obj.magic cty in
let _6 : unit = Obj.magic _6 in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 16679 "parsing/parser.ml"
+# 16629 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in
let virt : (Asttypes.virtual_flag) = Obj.magic virt in
let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 16694 "parsing/parser.ml"
+# 16644 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 16706 "parsing/parser.ml"
+# 16656 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 16714 "parsing/parser.ml"
+# 16664 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1972 "parsing/parser.mly"
+# 2022 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
let text = symbol_text _symbolstartpos in
Ci.mk id cty ~virt ~params ~attrs ~loc ~text ~docs
)
-# 16729 "parsing/parser.ml"
+# 16679 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 16735 "parsing/parser.ml"
+# 16685 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.class_type_declaration list) =
-# 211 "menhir/standard.mly"
+# 211 "<standard.mly>"
( [] )
-# 16753 "parsing/parser.ml"
+# 16703 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let csig : (Parsetree.class_type) = Obj.magic csig in
let _6 : unit = Obj.magic _6 in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 16826 "parsing/parser.ml"
+# 16776 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in
let virt : (Asttypes.virtual_flag) = Obj.magic virt in
let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 16841 "parsing/parser.ml"
+# 16791 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 16853 "parsing/parser.ml"
+# 16803 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 16861 "parsing/parser.ml"
+# 16811 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2011 "parsing/parser.mly"
+# 2061 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
let text = symbol_text _symbolstartpos in
Ci.mk id csig ~virt ~params ~attrs ~loc ~text ~docs
)
-# 16876 "parsing/parser.ml"
+# 16826 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 16882 "parsing/parser.ml"
+# 16832 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.module_binding list) =
-# 211 "menhir/standard.mly"
+# 211 "<standard.mly>"
( [] )
-# 16900 "parsing/parser.ml"
+# 16850 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 16963 "parsing/parser.ml"
+# 16913 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 16975 "parsing/parser.ml"
+# 16925 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 16983 "parsing/parser.ml"
+# 16933 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1363 "parsing/parser.mly"
+# 1413 "parsing/parser.mly"
(
let loc = make_loc _sloc in
let attrs = attrs1 @ attrs2 in
let text = symbol_text _symbolstartpos in
Mb.mk name body ~attrs ~loc ~text ~docs
)
-# 16998 "parsing/parser.ml"
+# 16948 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 17004 "parsing/parser.ml"
+# 16954 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.module_declaration list) =
-# 211 "menhir/standard.mly"
+# 211 "<standard.mly>"
( [] )
-# 17022 "parsing/parser.ml"
+# 16972 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 17092 "parsing/parser.ml"
+# 17042 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 17104 "parsing/parser.ml"
+# 17054 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 17112 "parsing/parser.ml"
+# 17062 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1639 "parsing/parser.mly"
+# 1689 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let docs = symbol_docs _sloc in
let text = symbol_text _symbolstartpos in
Md.mk name mty ~attrs ~loc ~text ~docs
)
-# 17127 "parsing/parser.ml"
+# 17077 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 17133 "parsing/parser.ml"
+# 17083 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.attributes) =
-# 211 "menhir/standard.mly"
+# 211 "<standard.mly>"
( [] )
-# 17151 "parsing/parser.ml"
+# 17101 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_xs_ in
let _v : (Parsetree.attributes) =
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 17183 "parsing/parser.ml"
+# 17133 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.type_declaration list) =
-# 211 "menhir/standard.mly"
+# 211 "<standard.mly>"
( [] )
-# 17201 "parsing/parser.ml"
+# 17151 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let xs_inlined1 : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) list) = Obj.magic xs_inlined1 in
let kind_priv_manifest : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic kind_priv_manifest in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 17268 "parsing/parser.ml"
+# 17218 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 17283 "parsing/parser.ml"
+# 17233 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let cstrs =
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 17292 "parsing/parser.ml"
+# 17242 "parsing/parser.ml"
in
-# 876 "parsing/parser.mly"
+# 897 "parsing/parser.mly"
( xs )
-# 17297 "parsing/parser.ml"
+# 17247 "parsing/parser.ml"
in
-# 2837 "parsing/parser.mly"
+# 2887 "parsing/parser.mly"
( _1 )
-# 17303 "parsing/parser.ml"
+# 17253 "parsing/parser.ml"
in
let id =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 17314 "parsing/parser.ml"
+# 17264 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 17322 "parsing/parser.ml"
+# 17272 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2826 "parsing/parser.mly"
+# 2876 "parsing/parser.mly"
(
let (kind, priv, manifest) = kind_priv_manifest in
let docs = symbol_docs _sloc in
let text = symbol_text _symbolstartpos in
Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs ~text
)
-# 17338 "parsing/parser.ml"
+# 17288 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 17344 "parsing/parser.ml"
+# 17294 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.type_declaration list) =
-# 211 "menhir/standard.mly"
+# 211 "<standard.mly>"
( [] )
-# 17362 "parsing/parser.ml"
+# 17312 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic _2 in
let _1_inlined3 : unit = Obj.magic _1_inlined3 in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 17436 "parsing/parser.ml"
+# 17386 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
let attrs2 =
let _1 = _1_inlined4 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 17451 "parsing/parser.ml"
+# 17401 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined4_ in
let cstrs =
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 17460 "parsing/parser.ml"
+# 17410 "parsing/parser.ml"
in
-# 876 "parsing/parser.mly"
+# 897 "parsing/parser.mly"
( xs )
-# 17465 "parsing/parser.ml"
+# 17415 "parsing/parser.ml"
in
-# 2837 "parsing/parser.mly"
+# 2887 "parsing/parser.mly"
( _1 )
-# 17471 "parsing/parser.ml"
+# 17421 "parsing/parser.ml"
in
let kind_priv_manifest =
let _1 = _1_inlined3 in
-# 2872 "parsing/parser.mly"
+# 2922 "parsing/parser.mly"
( _2 )
-# 17479 "parsing/parser.ml"
+# 17429 "parsing/parser.ml"
in
let id =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 17490 "parsing/parser.ml"
+# 17440 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 17498 "parsing/parser.ml"
+# 17448 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2826 "parsing/parser.mly"
+# 2876 "parsing/parser.mly"
(
let (kind, priv, manifest) = kind_priv_manifest in
let docs = symbol_docs _sloc in
let text = symbol_text _symbolstartpos in
Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs ~text
)
-# 17514 "parsing/parser.ml"
+# 17464 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 17520 "parsing/parser.ml"
+# 17470 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.attributes) =
-# 211 "menhir/standard.mly"
+# 211 "<standard.mly>"
( [] )
-# 17538 "parsing/parser.ml"
+# 17488 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_xs_ in
let _v : (Parsetree.attributes) =
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 17570 "parsing/parser.ml"
+# 17520 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.signature_item list list) =
-# 211 "menhir/standard.mly"
+# 211 "<standard.mly>"
( [] )
-# 17588 "parsing/parser.ml"
+# 17538 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _startpos = _startpos__1_ in
-# 802 "parsing/parser.mly"
+# 823 "parsing/parser.mly"
( text_sig _startpos )
-# 17623 "parsing/parser.ml"
+# 17573 "parsing/parser.ml"
in
-# 1501 "parsing/parser.mly"
+# 1551 "parsing/parser.mly"
( _1 )
-# 17629 "parsing/parser.ml"
+# 17579 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 17635 "parsing/parser.ml"
+# 17585 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _startpos = _startpos__1_ in
-# 800 "parsing/parser.mly"
+# 821 "parsing/parser.mly"
( text_sig _startpos @ [_1] )
-# 17670 "parsing/parser.ml"
+# 17620 "parsing/parser.ml"
in
-# 1501 "parsing/parser.mly"
+# 1551 "parsing/parser.mly"
( _1 )
-# 17676 "parsing/parser.ml"
+# 17626 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 17682 "parsing/parser.ml"
+# 17632 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.structure_item list list) =
-# 211 "menhir/standard.mly"
+# 211 "<standard.mly>"
( [] )
-# 17700 "parsing/parser.ml"
+# 17650 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let ys =
let items =
-# 862 "parsing/parser.mly"
+# 883 "parsing/parser.mly"
( [] )
-# 17735 "parsing/parser.ml"
+# 17685 "parsing/parser.ml"
in
-# 1247 "parsing/parser.mly"
+# 1297 "parsing/parser.mly"
( items )
-# 17740 "parsing/parser.ml"
+# 17690 "parsing/parser.ml"
in
let xs =
let _startpos = _startpos__1_ in
-# 798 "parsing/parser.mly"
+# 819 "parsing/parser.mly"
( text_str _startpos )
-# 17748 "parsing/parser.ml"
+# 17698 "parsing/parser.ml"
in
-# 267 "menhir/standard.mly"
+# 267 "<standard.mly>"
( xs @ ys )
-# 17754 "parsing/parser.ml"
+# 17704 "parsing/parser.ml"
in
-# 1263 "parsing/parser.mly"
+# 1313 "parsing/parser.mly"
( _1 )
-# 17760 "parsing/parser.ml"
+# 17710 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 17766 "parsing/parser.ml"
+# 17716 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _1 =
let attrs =
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 17820 "parsing/parser.ml"
+# 17770 "parsing/parser.ml"
in
-# 1254 "parsing/parser.mly"
+# 1304 "parsing/parser.mly"
( mkstrexp e attrs )
-# 17825 "parsing/parser.ml"
+# 17775 "parsing/parser.ml"
in
let _startpos__1_ = _startpos_e_ in
let _startpos = _startpos__1_ in
-# 796 "parsing/parser.mly"
+# 817 "parsing/parser.mly"
( text_str _startpos @ [_1] )
-# 17833 "parsing/parser.ml"
+# 17783 "parsing/parser.ml"
in
let _startpos__1_ = _startpos_e_ in
let _endpos = _endpos__1_ in
let _startpos = _startpos__1_ in
-# 815 "parsing/parser.mly"
+# 836 "parsing/parser.mly"
( mark_rhs_docs _startpos _endpos;
_1 )
-# 17843 "parsing/parser.ml"
+# 17793 "parsing/parser.ml"
in
-# 864 "parsing/parser.mly"
+# 885 "parsing/parser.mly"
( x )
-# 17849 "parsing/parser.ml"
+# 17799 "parsing/parser.ml"
in
-# 1247 "parsing/parser.mly"
+# 1297 "parsing/parser.mly"
( items )
-# 17855 "parsing/parser.ml"
+# 17805 "parsing/parser.ml"
in
let xs =
let _startpos = _startpos__1_ in
-# 798 "parsing/parser.mly"
+# 819 "parsing/parser.mly"
( text_str _startpos )
-# 17863 "parsing/parser.ml"
+# 17813 "parsing/parser.ml"
in
-# 267 "menhir/standard.mly"
+# 267 "<standard.mly>"
( xs @ ys )
-# 17869 "parsing/parser.ml"
+# 17819 "parsing/parser.ml"
in
-# 1263 "parsing/parser.mly"
+# 1313 "parsing/parser.mly"
( _1 )
-# 17875 "parsing/parser.ml"
+# 17825 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 17881 "parsing/parser.ml"
+# 17831 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _startpos = _startpos__1_ in
-# 796 "parsing/parser.mly"
+# 817 "parsing/parser.mly"
( text_str _startpos @ [_1] )
-# 17916 "parsing/parser.ml"
+# 17866 "parsing/parser.ml"
in
-# 1263 "parsing/parser.mly"
+# 1313 "parsing/parser.mly"
( _1 )
-# 17922 "parsing/parser.ml"
+# 17872 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 17928 "parsing/parser.ml"
+# 17878 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.class_type_field list list) =
-# 211 "menhir/standard.mly"
+# 211 "<standard.mly>"
( [] )
-# 17946 "parsing/parser.ml"
+# 17896 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.class_type_field list list) = let x =
let _startpos = _startpos__1_ in
-# 810 "parsing/parser.mly"
+# 831 "parsing/parser.mly"
( text_csig _startpos @ [_1] )
-# 17980 "parsing/parser.ml"
+# 17930 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 17986 "parsing/parser.ml"
+# 17936 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.class_field list list) =
-# 211 "menhir/standard.mly"
+# 211 "<standard.mly>"
( [] )
-# 18004 "parsing/parser.ml"
+# 17954 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.class_field list list) = let x =
let _startpos = _startpos__1_ in
-# 808 "parsing/parser.mly"
+# 829 "parsing/parser.mly"
( text_cstr _startpos @ [_1] )
-# 18038 "parsing/parser.ml"
+# 17988 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 18044 "parsing/parser.ml"
+# 17994 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.structure_item list list) =
-# 211 "menhir/standard.mly"
+# 211 "<standard.mly>"
( [] )
-# 18062 "parsing/parser.ml"
+# 18012 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.structure_item list list) = let x =
let _startpos = _startpos__1_ in
-# 796 "parsing/parser.mly"
+# 817 "parsing/parser.mly"
( text_str _startpos @ [_1] )
-# 18096 "parsing/parser.ml"
+# 18046 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 18102 "parsing/parser.ml"
+# 18052 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.toplevel_phrase list list) =
-# 211 "menhir/standard.mly"
+# 211 "<standard.mly>"
( [] )
-# 18120 "parsing/parser.ml"
+# 18070 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let x =
let _1 =
-# 862 "parsing/parser.mly"
+# 883 "parsing/parser.mly"
( [] )
-# 18155 "parsing/parser.ml"
+# 18105 "parsing/parser.ml"
in
-# 1092 "parsing/parser.mly"
+# 1113 "parsing/parser.mly"
( _1 )
-# 18160 "parsing/parser.ml"
+# 18110 "parsing/parser.ml"
in
-# 183 "menhir/standard.mly"
+# 183 "<standard.mly>"
( x )
-# 18166 "parsing/parser.ml"
+# 18116 "parsing/parser.ml"
in
-# 1104 "parsing/parser.mly"
+# 1125 "parsing/parser.mly"
( _1 )
-# 18172 "parsing/parser.ml"
+# 18122 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 18178 "parsing/parser.ml"
+# 18128 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _1 =
let attrs =
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 18232 "parsing/parser.ml"
+# 18182 "parsing/parser.ml"
in
-# 1254 "parsing/parser.mly"
+# 1304 "parsing/parser.mly"
( mkstrexp e attrs )
-# 18237 "parsing/parser.ml"
+# 18187 "parsing/parser.ml"
in
-# 806 "parsing/parser.mly"
+# 827 "parsing/parser.mly"
( Ptop_def [_1] )
-# 18243 "parsing/parser.ml"
+# 18193 "parsing/parser.ml"
in
let _startpos__1_ = _startpos_e_ in
let _startpos = _startpos__1_ in
-# 804 "parsing/parser.mly"
+# 825 "parsing/parser.mly"
( text_def _startpos @ [_1] )
-# 18251 "parsing/parser.ml"
+# 18201 "parsing/parser.ml"
in
-# 864 "parsing/parser.mly"
+# 885 "parsing/parser.mly"
( x )
-# 18257 "parsing/parser.ml"
+# 18207 "parsing/parser.ml"
in
-# 1092 "parsing/parser.mly"
+# 1113 "parsing/parser.mly"
( _1 )
-# 18263 "parsing/parser.ml"
+# 18213 "parsing/parser.ml"
in
-# 183 "menhir/standard.mly"
+# 183 "<standard.mly>"
( x )
-# 18269 "parsing/parser.ml"
+# 18219 "parsing/parser.ml"
in
-# 1104 "parsing/parser.mly"
+# 1125 "parsing/parser.mly"
( _1 )
-# 18275 "parsing/parser.ml"
+# 18225 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 18281 "parsing/parser.ml"
+# 18231 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.toplevel_phrase list list) = let x =
let _1 =
let _1 =
-# 806 "parsing/parser.mly"
+# 827 "parsing/parser.mly"
( Ptop_def [_1] )
-# 18315 "parsing/parser.ml"
+# 18265 "parsing/parser.ml"
in
let _startpos = _startpos__1_ in
-# 804 "parsing/parser.mly"
+# 825 "parsing/parser.mly"
( text_def _startpos @ [_1] )
-# 18321 "parsing/parser.ml"
+# 18271 "parsing/parser.ml"
in
-# 1104 "parsing/parser.mly"
+# 1125 "parsing/parser.mly"
( _1 )
-# 18327 "parsing/parser.ml"
+# 18277 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 18333 "parsing/parser.ml"
+# 18283 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _startpos = _startpos__1_ in
-# 815 "parsing/parser.mly"
+# 836 "parsing/parser.mly"
( mark_rhs_docs _startpos _endpos;
_1 )
-# 18371 "parsing/parser.ml"
+# 18321 "parsing/parser.ml"
in
let _startpos = _startpos__1_ in
-# 804 "parsing/parser.mly"
+# 825 "parsing/parser.mly"
( text_def _startpos @ [_1] )
-# 18378 "parsing/parser.ml"
+# 18328 "parsing/parser.ml"
in
-# 1104 "parsing/parser.mly"
+# 1125 "parsing/parser.mly"
( _1 )
-# 18384 "parsing/parser.ml"
+# 18334 "parsing/parser.ml"
in
-# 213 "menhir/standard.mly"
+# 213 "<standard.mly>"
( x :: xs )
-# 18390 "parsing/parser.ml"
+# 18340 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_opat_ in
let _v : ((Longident.t Asttypes.loc * Parsetree.pattern) list * unit option) = let _2 =
-# 124 "menhir/standard.mly"
+# 124 "<standard.mly>"
( None )
-# 18429 "parsing/parser.ml"
+# 18379 "parsing/parser.ml"
in
let x =
let label =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 18439 "parsing/parser.ml"
+# 18389 "parsing/parser.ml"
in
let _startpos_label_ = _startpos__1_ in
let _symbolstartpos = _startpos_label_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2715 "parsing/parser.mly"
+# 2765 "parsing/parser.mly"
( let pat =
match opat with
| None ->
in
label, mkpat_opt_constraint ~loc:_sloc pat octy
)
-# 18458 "parsing/parser.ml"
+# 18408 "parsing/parser.ml"
in
-# 1031 "parsing/parser.mly"
+# 1052 "parsing/parser.mly"
( [x], None )
-# 18464 "parsing/parser.ml"
+# 18414 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_x_ in
let _v : ((Longident.t Asttypes.loc * Parsetree.pattern) list * unit option) = let _2 =
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 18510 "parsing/parser.ml"
+# 18460 "parsing/parser.ml"
in
let x =
let label =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 18520 "parsing/parser.ml"
+# 18470 "parsing/parser.ml"
in
let _startpos_label_ = _startpos__1_ in
let _symbolstartpos = _startpos_label_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2715 "parsing/parser.mly"
+# 2765 "parsing/parser.mly"
( let pat =
match opat with
| None ->
in
label, mkpat_opt_constraint ~loc:_sloc pat octy
)
-# 18539 "parsing/parser.ml"
+# 18489 "parsing/parser.ml"
in
-# 1031 "parsing/parser.mly"
+# 1052 "parsing/parser.mly"
( [x], None )
-# 18545 "parsing/parser.ml"
+# 18495 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 18610 "parsing/parser.ml"
+# 18560 "parsing/parser.ml"
in
let _startpos_label_ = _startpos__1_ in
let _symbolstartpos = _startpos_label_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2715 "parsing/parser.mly"
+# 2765 "parsing/parser.mly"
( let pat =
match opat with
| None ->
in
label, mkpat_opt_constraint ~loc:_sloc pat octy
)
-# 18629 "parsing/parser.ml"
+# 18579 "parsing/parser.ml"
in
-# 1033 "parsing/parser.mly"
+# 1054 "parsing/parser.mly"
( [x], Some y )
-# 18635 "parsing/parser.ml"
+# 18585 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 18693 "parsing/parser.ml"
+# 18643 "parsing/parser.ml"
in
let _startpos_label_ = _startpos__1_ in
let _symbolstartpos = _startpos_label_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2715 "parsing/parser.mly"
+# 2765 "parsing/parser.mly"
( let pat =
match opat with
| None ->
in
label, mkpat_opt_constraint ~loc:_sloc pat octy
)
-# 18712 "parsing/parser.ml"
+# 18662 "parsing/parser.ml"
in
-# 1037 "parsing/parser.mly"
+# 1058 "parsing/parser.mly"
( let xs, y = tail in
x :: xs, y )
-# 18719 "parsing/parser.ml"
+# 18669 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.case) =
-# 2473 "parsing/parser.mly"
+# 2523 "parsing/parser.mly"
( Exp.case _1 _3 )
-# 18758 "parsing/parser.ml"
+# 18708 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : (Parsetree.case) =
-# 2475 "parsing/parser.mly"
+# 2525 "parsing/parser.mly"
( Exp.case _1 ~guard:_3 _5 )
-# 18811 "parsing/parser.ml"
+# 18761 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__3_ in
let _v : (Parsetree.case) = let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2477 "parsing/parser.mly"
+# 2527 "parsing/parser.mly"
( Exp.case _1 (Exp.unreachable ~loc:(make_loc _loc__3_) ()) )
-# 18851 "parsing/parser.ml"
+# 18801 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined1 : (Parsetree.core_type) = Obj.magic _1_inlined1 in
let _2 : unit = Obj.magic _2 in
let _1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 18914 "parsing/parser.ml"
+# 18864 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _6 =
let _1 = _1_inlined3 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 18925 "parsing/parser.ml"
+# 18875 "parsing/parser.ml"
in
let _endpos__6_ = _endpos__1_inlined3_ in
let _4 =
let _1 = _1_inlined2 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 18934 "parsing/parser.ml"
+# 18884 "parsing/parser.ml"
in
let _endpos__4_ = _endpos__1_inlined2_ in
let _3 =
let _1 = _1_inlined1 in
-# 3118 "parsing/parser.mly"
+# 3168 "parsing/parser.mly"
( _1 )
-# 18943 "parsing/parser.ml"
+# 18893 "parsing/parser.ml"
in
let _1 =
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 18950 "parsing/parser.ml"
+# 18900 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 18958 "parsing/parser.ml"
+# 18908 "parsing/parser.ml"
in
let _endpos = _endpos__6_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3328 "parsing/parser.mly"
+# 3378 "parsing/parser.mly"
( let info =
match rhs_info _endpos__4_ with
| Some _ as info_before_semi -> info_before_semi
in
let attrs = add_info_attrs info (_4 @ _6) in
Of.tag ~loc:(make_loc _sloc) ~attrs _1 _3 )
-# 18973 "parsing/parser.ml"
+# 18923 "parsing/parser.ml"
in
-# 3309 "parsing/parser.mly"
+# 3359 "parsing/parser.mly"
( let (f, c) = tail in (head :: f, c) )
-# 18979 "parsing/parser.ml"
+# 18929 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos_ty_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3339 "parsing/parser.mly"
+# 3389 "parsing/parser.mly"
( Of.inherit_ ~loc:(make_loc _sloc) ty )
-# 19022 "parsing/parser.ml"
+# 18972 "parsing/parser.ml"
in
-# 3309 "parsing/parser.mly"
+# 3359 "parsing/parser.mly"
( let (f, c) = tail in (head :: f, c) )
-# 19028 "parsing/parser.ml"
+# 18978 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined1 : (Parsetree.core_type) = Obj.magic _1_inlined1 in
let _2 : unit = Obj.magic _2 in
let _1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 19084 "parsing/parser.ml"
+# 19034 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _6 =
let _1 = _1_inlined3 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 19095 "parsing/parser.ml"
+# 19045 "parsing/parser.ml"
in
let _endpos__6_ = _endpos__1_inlined3_ in
let _4 =
let _1 = _1_inlined2 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 19104 "parsing/parser.ml"
+# 19054 "parsing/parser.ml"
in
let _endpos__4_ = _endpos__1_inlined2_ in
let _3 =
let _1 = _1_inlined1 in
-# 3118 "parsing/parser.mly"
+# 3168 "parsing/parser.mly"
( _1 )
-# 19113 "parsing/parser.ml"
+# 19063 "parsing/parser.ml"
in
let _1 =
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 19120 "parsing/parser.ml"
+# 19070 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 19128 "parsing/parser.ml"
+# 19078 "parsing/parser.ml"
in
let _endpos = _endpos__6_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3328 "parsing/parser.mly"
+# 3378 "parsing/parser.mly"
( let info =
match rhs_info _endpos__4_ with
| Some _ as info_before_semi -> info_before_semi
in
let attrs = add_info_attrs info (_4 @ _6) in
Of.tag ~loc:(make_loc _sloc) ~attrs _1 _3 )
-# 19143 "parsing/parser.ml"
+# 19093 "parsing/parser.ml"
in
-# 3312 "parsing/parser.mly"
+# 3362 "parsing/parser.mly"
( [head], Closed )
-# 19149 "parsing/parser.ml"
+# 19099 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos_ty_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3339 "parsing/parser.mly"
+# 3389 "parsing/parser.mly"
( Of.inherit_ ~loc:(make_loc _sloc) ty )
-# 19185 "parsing/parser.ml"
+# 19135 "parsing/parser.ml"
in
-# 3312 "parsing/parser.mly"
+# 3362 "parsing/parser.mly"
( [head], Closed )
-# 19191 "parsing/parser.ml"
+# 19141 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined1 : (Parsetree.core_type) = Obj.magic _1_inlined1 in
let _2 : unit = Obj.magic _2 in
let _1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 19233 "parsing/parser.ml"
+# 19183 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _4 =
let _1 = _1_inlined2 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 19244 "parsing/parser.ml"
+# 19194 "parsing/parser.ml"
in
let _endpos__4_ = _endpos__1_inlined2_ in
let _3 =
let _1 = _1_inlined1 in
-# 3118 "parsing/parser.mly"
+# 3168 "parsing/parser.mly"
( _1 )
-# 19253 "parsing/parser.ml"
+# 19203 "parsing/parser.ml"
in
let _1 =
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 19260 "parsing/parser.ml"
+# 19210 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 19268 "parsing/parser.ml"
+# 19218 "parsing/parser.ml"
in
let _endpos = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3321 "parsing/parser.mly"
+# 3371 "parsing/parser.mly"
( let info = symbol_info _endpos in
let attrs = add_info_attrs info _4 in
Of.tag ~loc:(make_loc _sloc) ~attrs _1 _3 )
-# 19279 "parsing/parser.ml"
+# 19229 "parsing/parser.ml"
in
-# 3315 "parsing/parser.mly"
+# 3365 "parsing/parser.mly"
( [head], Closed )
-# 19285 "parsing/parser.ml"
+# 19235 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos_ty_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3339 "parsing/parser.mly"
+# 3389 "parsing/parser.mly"
( Of.inherit_ ~loc:(make_loc _sloc) ty )
-# 19314 "parsing/parser.ml"
+# 19264 "parsing/parser.ml"
in
-# 3315 "parsing/parser.mly"
+# 3365 "parsing/parser.mly"
( [head], Closed )
-# 19320 "parsing/parser.ml"
+# 19270 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.object_field list * Asttypes.closed_flag) =
-# 3317 "parsing/parser.mly"
+# 3367 "parsing/parser.mly"
( [], Open )
-# 19345 "parsing/parser.ml"
+# 19295 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined2 : (Parsetree.core_type) = Obj.magic _1_inlined2 in
let _5 : unit = Obj.magic _5 in
let _1_inlined1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 19392 "parsing/parser.ml"
+# 19342 "parsing/parser.ml"
) = Obj.magic _1_inlined1 in
let private_ : (Asttypes.private_flag) = Obj.magic private_ in
let _1 : (Parsetree.attributes) = Obj.magic _1 in
Parsetree.attributes) = let ty =
let _1 = _1_inlined2 in
-# 3114 "parsing/parser.mly"
+# 3164 "parsing/parser.mly"
( _1 )
-# 19406 "parsing/parser.ml"
+# 19356 "parsing/parser.ml"
in
let label =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 19414 "parsing/parser.ml"
+# 19364 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 19422 "parsing/parser.ml"
+# 19372 "parsing/parser.ml"
in
let attrs =
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 19428 "parsing/parser.ml"
+# 19378 "parsing/parser.ml"
in
let _1 =
-# 3568 "parsing/parser.mly"
+# 3630 "parsing/parser.mly"
( Fresh )
-# 19433 "parsing/parser.ml"
+# 19383 "parsing/parser.ml"
in
-# 1819 "parsing/parser.mly"
+# 1869 "parsing/parser.mly"
( (label, private_, Cfk_virtual ty), attrs )
-# 19438 "parsing/parser.ml"
+# 19388 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _5 : (Parsetree.expression) = Obj.magic _5 in
let _1_inlined1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 19478 "parsing/parser.ml"
+# 19428 "parsing/parser.ml"
) = Obj.magic _1_inlined1 in
let _3 : (Asttypes.private_flag) = Obj.magic _3 in
let _1 : (Parsetree.attributes) = Obj.magic _1 in
Parsetree.attributes) = let _4 =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 19492 "parsing/parser.ml"
+# 19442 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 19500 "parsing/parser.ml"
+# 19450 "parsing/parser.ml"
in
let _2 =
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 19506 "parsing/parser.ml"
+# 19456 "parsing/parser.ml"
in
let _1 =
-# 3571 "parsing/parser.mly"
+# 3633 "parsing/parser.mly"
( Fresh )
-# 19511 "parsing/parser.ml"
+# 19461 "parsing/parser.ml"
in
-# 1821 "parsing/parser.mly"
+# 1871 "parsing/parser.mly"
( let e = _5 in
let loc = Location.(e.pexp_loc.loc_start, e.pexp_loc.loc_end) in
(_4, _3,
Cfk_concrete (_1, ghexp ~loc (Pexp_poly (e, None)))), _2 )
-# 19519 "parsing/parser.ml"
+# 19469 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _5 : (Parsetree.expression) = Obj.magic _5 in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 19565 "parsing/parser.ml"
+# 19515 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let _3 : (Asttypes.private_flag) = Obj.magic _3 in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
Parsetree.attributes) = let _4 =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 19580 "parsing/parser.ml"
+# 19530 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 19588 "parsing/parser.ml"
+# 19538 "parsing/parser.ml"
in
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 19596 "parsing/parser.ml"
+# 19546 "parsing/parser.ml"
in
let _1 =
-# 3572 "parsing/parser.mly"
+# 3634 "parsing/parser.mly"
( Override )
-# 19602 "parsing/parser.ml"
+# 19552 "parsing/parser.ml"
in
-# 1821 "parsing/parser.mly"
+# 1871 "parsing/parser.mly"
( let e = _5 in
let loc = Location.(e.pexp_loc.loc_start, e.pexp_loc.loc_end) in
(_4, _3,
Cfk_concrete (_1, ghexp ~loc (Pexp_poly (e, None)))), _2 )
-# 19610 "parsing/parser.ml"
+# 19560 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined2 : (Parsetree.core_type) = Obj.magic _1_inlined2 in
let _5 : unit = Obj.magic _5 in
let _1_inlined1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 19671 "parsing/parser.ml"
+# 19621 "parsing/parser.ml"
) = Obj.magic _1_inlined1 in
let _3 : (Asttypes.private_flag) = Obj.magic _3 in
let _1 : (Parsetree.attributes) = Obj.magic _1 in
Parsetree.attributes) = let _6 =
let _1 = _1_inlined2 in
-# 3114 "parsing/parser.mly"
+# 3164 "parsing/parser.mly"
( _1 )
-# 19685 "parsing/parser.ml"
+# 19635 "parsing/parser.ml"
in
let _startpos__6_ = _startpos__1_inlined2_ in
let _4 =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 19694 "parsing/parser.ml"
+# 19644 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 19702 "parsing/parser.ml"
+# 19652 "parsing/parser.ml"
in
let _2 =
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 19708 "parsing/parser.ml"
+# 19658 "parsing/parser.ml"
in
let _1 =
-# 3571 "parsing/parser.mly"
+# 3633 "parsing/parser.mly"
( Fresh )
-# 19713 "parsing/parser.ml"
+# 19663 "parsing/parser.ml"
in
-# 1827 "parsing/parser.mly"
+# 1877 "parsing/parser.mly"
( let poly_exp =
let loc = (_startpos__6_, _endpos__8_) in
ghexp ~loc (Pexp_poly(_8, Some _6)) in
(_4, _3, Cfk_concrete (_1, poly_exp)), _2 )
-# 19721 "parsing/parser.ml"
+# 19671 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined3 : (Parsetree.core_type) = Obj.magic _1_inlined3 in
let _5 : unit = Obj.magic _5 in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 19788 "parsing/parser.ml"
+# 19738 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let _3 : (Asttypes.private_flag) = Obj.magic _3 in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
Parsetree.attributes) = let _6 =
let _1 = _1_inlined3 in
-# 3114 "parsing/parser.mly"
+# 3164 "parsing/parser.mly"
( _1 )
-# 19803 "parsing/parser.ml"
+# 19753 "parsing/parser.ml"
in
let _startpos__6_ = _startpos__1_inlined3_ in
let _4 =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 19812 "parsing/parser.ml"
+# 19762 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 19820 "parsing/parser.ml"
+# 19770 "parsing/parser.ml"
in
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 19828 "parsing/parser.ml"
+# 19778 "parsing/parser.ml"
in
let _1 =
-# 3572 "parsing/parser.mly"
+# 3634 "parsing/parser.mly"
( Override )
-# 19834 "parsing/parser.ml"
+# 19784 "parsing/parser.ml"
in
-# 1827 "parsing/parser.mly"
+# 1877 "parsing/parser.mly"
( let poly_exp =
let loc = (_startpos__6_, _endpos__8_) in
ghexp ~loc (Pexp_poly(_8, Some _6)) in
(_4, _3, Cfk_concrete (_1, poly_exp)), _2 )
-# 19842 "parsing/parser.ml"
+# 19792 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _6 : unit = Obj.magic _6 in
let _5 : unit = Obj.magic _5 in
let _1_inlined1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 19924 "parsing/parser.ml"
+# 19874 "parsing/parser.ml"
) = Obj.magic _1_inlined1 in
let _3 : (Asttypes.private_flag) = Obj.magic _3 in
let _1 : (Parsetree.attributes) = Obj.magic _1 in
let _v : ((Asttypes.label Asttypes.loc * Asttypes.private_flag *
Parsetree.class_field_kind) *
Parsetree.attributes) = let _7 =
-# 2364 "parsing/parser.mly"
+# 2414 "parsing/parser.mly"
( xs )
-# 19936 "parsing/parser.ml"
+# 19886 "parsing/parser.ml"
in
let _startpos__7_ = _startpos_xs_ in
let _4 =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 19944 "parsing/parser.ml"
+# 19894 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 19952 "parsing/parser.ml"
+# 19902 "parsing/parser.ml"
in
let _startpos__4_ = _startpos__1_inlined1_ in
let _2 =
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 19959 "parsing/parser.ml"
+# 19909 "parsing/parser.ml"
in
let (_endpos__2_, _startpos__2_) = (_endpos__1_, _startpos__1_) in
let _1 =
-# 3571 "parsing/parser.mly"
+# 3633 "parsing/parser.mly"
( Fresh )
-# 19965 "parsing/parser.ml"
+# 19915 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos__0_, _endpos__0_) in
let _endpos = _endpos__11_ in
_startpos__4_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1833 "parsing/parser.mly"
+# 1883 "parsing/parser.mly"
( let poly_exp_loc = (_startpos__7_, _endpos__11_) in
let poly_exp =
let exp, poly =
ghexp ~loc:poly_exp_loc (Pexp_poly(exp, Some poly)) in
(_4, _3,
Cfk_concrete (_1, poly_exp)), _2 )
-# 19992 "parsing/parser.ml"
+# 19942 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _6 : unit = Obj.magic _6 in
let _5 : unit = Obj.magic _5 in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 20080 "parsing/parser.ml"
+# 20030 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let _3 : (Asttypes.private_flag) = Obj.magic _3 in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
let _v : ((Asttypes.label Asttypes.loc * Asttypes.private_flag *
Parsetree.class_field_kind) *
Parsetree.attributes) = let _7 =
-# 2364 "parsing/parser.mly"
+# 2414 "parsing/parser.mly"
( xs )
-# 20093 "parsing/parser.ml"
+# 20043 "parsing/parser.ml"
in
let _startpos__7_ = _startpos_xs_ in
let _4 =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 20101 "parsing/parser.ml"
+# 20051 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 20109 "parsing/parser.ml"
+# 20059 "parsing/parser.ml"
in
let _startpos__4_ = _startpos__1_inlined2_ in
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 20118 "parsing/parser.ml"
+# 20068 "parsing/parser.ml"
in
let (_endpos__2_, _startpos__2_) = (_endpos__1_inlined1_, _startpos__1_inlined1_) in
let _1 =
-# 3572 "parsing/parser.mly"
+# 3634 "parsing/parser.mly"
( Override )
-# 20125 "parsing/parser.ml"
+# 20075 "parsing/parser.ml"
in
let _endpos = _endpos__11_ in
let _symbolstartpos = if _startpos__1_ != _endpos__1_ then
_startpos__4_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1833 "parsing/parser.mly"
+# 1883 "parsing/parser.mly"
( let poly_exp_loc = (_startpos__7_, _endpos__11_) in
let poly_exp =
let exp, poly =
ghexp ~loc:poly_exp_loc (Pexp_poly(exp, Some poly)) in
(_4, _3,
Cfk_concrete (_1, poly_exp)), _2 )
-# 20151 "parsing/parser.ml"
+# 20101 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 688 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 20172 "parsing/parser.ml"
+# 20122 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Longident.t) =
-# 3450 "parsing/parser.mly"
- ( Lident _1 )
-# 20180 "parsing/parser.ml"
+# 3490 "parsing/parser.mly"
+ ( Lident _1 )
+# 20130 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _3;
+ MenhirLib.EngineTypes.startp = _startpos__3_;
+ MenhirLib.EngineTypes.endp = _endpos__3_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2;
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
+ };
+ } = _menhir_stack in
+ let _3 : (
+# 647 "parsing/parser.mly"
+ (string)
+# 20163 "parsing/parser.ml"
+ ) = Obj.magic _3 in
+ let _2 : unit = Obj.magic _2 in
+ let _1 : (Longident.t) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__3_ in
+ let _v : (Longident.t) =
+# 3491 "parsing/parser.mly"
+ ( Ldot(_1,_3) )
+# 20173 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ } = _menhir_stack in
+ let _1 : (
+# 697 "parsing/parser.mly"
+ (string)
+# 20194 "parsing/parser.ml"
+ ) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_ in
+ let _v : (Longident.t) =
+# 3490 "parsing/parser.mly"
+ ( Lident _1 )
+# 20202 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _3;
+ MenhirLib.EngineTypes.startp = _startpos__3_;
+ MenhirLib.EngineTypes.endp = _endpos__3_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2;
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
+ };
+ } = _menhir_stack in
+ let _3 : (
+# 697 "parsing/parser.mly"
+ (string)
+# 20235 "parsing/parser.ml"
+ ) = Obj.magic _3 in
+ let _2 : unit = Obj.magic _2 in
+ let _1 : (Longident.t) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__3_ in
+ let _v : (Longident.t) =
+# 3491 "parsing/parser.mly"
+ ( Ldot(_1,_3) )
+# 20245 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ } = _menhir_stack in
+ let _1 : (Asttypes.label) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_ in
+ let _v : (Longident.t) = let _1 =
+# 3527 "parsing/parser.mly"
+ ( _1 )
+# 20270 "parsing/parser.ml"
+ in
+
+# 3490 "parsing/parser.mly"
+ ( Lident _1 )
+# 20275 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _3;
+ MenhirLib.EngineTypes.startp = _startpos__3_;
+ MenhirLib.EngineTypes.endp = _endpos__3_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2;
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
+ };
+ } = _menhir_stack in
+ let _3 : unit = Obj.magic _3 in
+ let _2 : unit = Obj.magic _2 in
+ let _1 : unit = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__3_ in
+ let _v : (Longident.t) = let _1 =
+ let _1 =
+# 3470 "parsing/parser.mly"
+ ( "::" )
+# 20315 "parsing/parser.ml"
+ in
+
+# 3527 "parsing/parser.mly"
+ ( _1 )
+# 20320 "parsing/parser.ml"
+
+ in
+
+# 3490 "parsing/parser.mly"
+ ( Lident _1 )
+# 20326 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ } = _menhir_stack in
+ let _1 : (Asttypes.label) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_ in
+ let _v : (Longident.t) = let _1 =
+# 3527 "parsing/parser.mly"
+ ( _1 )
+# 20351 "parsing/parser.ml"
+ in
+
+# 3490 "parsing/parser.mly"
+ ( Lident _1 )
+# 20356 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _1_inlined1;
+ MenhirLib.EngineTypes.startp = _startpos__1_inlined1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_inlined1_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2;
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
+ };
+ } = _menhir_stack in
+ let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in
+ let _2 : unit = Obj.magic _2 in
+ let _1 : (Longident.t) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_inlined1_ in
+ let _v : (Longident.t) = let _3 =
+ let _1 = _1_inlined1 in
+
+# 3527 "parsing/parser.mly"
+ ( _1 )
+# 20397 "parsing/parser.ml"
+
+ in
+
+# 3491 "parsing/parser.mly"
+ ( Ldot(_1,_3) )
+# 20403 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _3;
+ MenhirLib.EngineTypes.startp = _startpos__3_;
+ MenhirLib.EngineTypes.endp = _endpos__3_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2_inlined1;
+ MenhirLib.EngineTypes.startp = _startpos__2_inlined1_;
+ MenhirLib.EngineTypes.endp = _endpos__2_inlined1_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _1_inlined1;
+ MenhirLib.EngineTypes.startp = _startpos__1_inlined1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_inlined1_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2;
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
+ };
+ };
+ };
+ } = _menhir_stack in
+ let _3 : unit = Obj.magic _3 in
+ let _2_inlined1 : unit = Obj.magic _2_inlined1 in
+ let _1_inlined1 : unit = Obj.magic _1_inlined1 in
+ let _2 : unit = Obj.magic _2 in
+ let _1 : (Longident.t) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__3_ in
+ let _v : (Longident.t) = let _3 =
+ let (_2, _1) = (_2_inlined1, _1_inlined1) in
+ let _1 =
+# 3470 "parsing/parser.mly"
+ ( "::" )
+# 20458 "parsing/parser.ml"
+ in
+
+# 3527 "parsing/parser.mly"
+ ( _1 )
+# 20463 "parsing/parser.ml"
+
+ in
+
+# 3491 "parsing/parser.mly"
+ ( Ldot(_1,_3) )
+# 20469 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _1_inlined1;
+ MenhirLib.EngineTypes.startp = _startpos__1_inlined1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_inlined1_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2;
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
+ };
+ } = _menhir_stack in
+ let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in
+ let _2 : unit = Obj.magic _2 in
+ let _1 : (Longident.t) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_inlined1_ in
+ let _v : (Longident.t) = let _3 =
+ let _1 = _1_inlined1 in
+
+# 3527 "parsing/parser.mly"
+ ( _1 )
+# 20510 "parsing/parser.ml"
+
+ in
+
+# 3491 "parsing/parser.mly"
+ ( Ldot(_1,_3) )
+# 20516 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ } = _menhir_stack in
+ let _1 : (Asttypes.label) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_ in
+ let _v : (Longident.t) =
+# 3490 "parsing/parser.mly"
+ ( Lident _1 )
+# 20541 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _3;
+ MenhirLib.EngineTypes.startp = _startpos__3_;
+ MenhirLib.EngineTypes.endp = _endpos__3_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2;
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
+ };
+ } = _menhir_stack in
+ let _3 : (Asttypes.label) = Obj.magic _3 in
+ let _2 : unit = Obj.magic _2 in
+ let _1 : (Longident.t) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__3_ in
+ let _v : (Longident.t) =
+# 3491 "parsing/parser.mly"
+ ( Ldot(_1,_3) )
+# 20580 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ } = _menhir_stack in
+ let _1 : (
+# 647 "parsing/parser.mly"
+ (string)
+# 20601 "parsing/parser.ml"
+ ) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_ in
+ let _v : (Longident.t) =
+# 3490 "parsing/parser.mly"
+ ( Lident _1 )
+# 20609 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _3;
+ MenhirLib.EngineTypes.startp = _startpos__3_;
+ MenhirLib.EngineTypes.endp = _endpos__3_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2;
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
+ };
+ } = _menhir_stack in
+ let _3 : (
+# 647 "parsing/parser.mly"
+ (string)
+# 20642 "parsing/parser.ml"
+ ) = Obj.magic _3 in
+ let _2 : unit = Obj.magic _2 in
+ let _1 : (Longident.t) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__3_ in
+ let _v : (Longident.t) =
+# 3491 "parsing/parser.mly"
+ ( Ldot(_1,_3) )
+# 20652 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ } = _menhir_stack in
+ let _1 : (
+# 697 "parsing/parser.mly"
+ (string)
+# 20673 "parsing/parser.ml"
+ ) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_ in
+ let _v : (Longident.t) =
+# 3490 "parsing/parser.mly"
+ ( Lident _1 )
+# 20681 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _3;
+ MenhirLib.EngineTypes.startp = _startpos__3_;
+ MenhirLib.EngineTypes.endp = _endpos__3_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2;
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
+ };
+ } = _menhir_stack in
+ let _3 : (
+# 697 "parsing/parser.mly"
+ (string)
+# 20714 "parsing/parser.ml"
+ ) = Obj.magic _3 in
+ let _2 : unit = Obj.magic _2 in
+ let _1 : (Longident.t) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__3_ in
+ let _v : (Longident.t) =
+# 3491 "parsing/parser.mly"
+ ( Ldot(_1,_3) )
+# 20724 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ } = _menhir_stack in
+ let _1 : (Asttypes.label) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_ in
+ let _v : (Longident.t) =
+# 3490 "parsing/parser.mly"
+ ( Lident _1 )
+# 20749 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
};
} = _menhir_stack in
- let _3 : (
-# 688 "parsing/parser.mly"
- (string)
-# 20213 "parsing/parser.ml"
- ) = Obj.magic _3 in
+ let _3 : (Asttypes.label) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _1 : (Longident.t) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (Longident.t) =
-# 3451 "parsing/parser.mly"
- ( Ldot(_1, _3) )
-# 20223 "parsing/parser.ml"
+# 3491 "parsing/parser.mly"
+ ( Ldot(_1,_3) )
+# 20788 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ } = _menhir_stack in
+ let _1 : (Longident.t) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_ in
+ let _v : (Longident.t) =
+# 3506 "parsing/parser.mly"
+ ( _1 )
+# 20813 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3453 "parsing/parser.mly"
+# 3508 "parsing/parser.mly"
( lapply ~loc:_sloc _1 _3 )
-# 20272 "parsing/parser.ml"
+# 20862 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__3_ in
let _v : (Longident.t) = let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 3455 "parsing/parser.mly"
+# 3510 "parsing/parser.mly"
( expecting _loc__3_ "module path" )
-# 20312 "parsing/parser.ml"
+# 20902 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.endp = _endpos__1_;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
- let _1 : (
-# 688 "parsing/parser.mly"
- (string)
-# 20333 "parsing/parser.ml"
- ) = Obj.magic _1 in
- let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
- let _startpos = _startpos__1_ in
- let _endpos = _endpos__1_ in
- let _v : (Longident.t) =
-# 3446 "parsing/parser.mly"
- ( Lident _1 )
-# 20341 "parsing/parser.ml"
- in
- {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = Obj.repr _v;
- MenhirLib.EngineTypes.startp = _startpos;
- MenhirLib.EngineTypes.endp = _endpos;
- MenhirLib.EngineTypes.next = _menhir_stack;
- });
- (fun _menhir_env ->
- let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
- let {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _3;
- MenhirLib.EngineTypes.startp = _startpos__3_;
- MenhirLib.EngineTypes.endp = _endpos__3_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _2;
- MenhirLib.EngineTypes.startp = _startpos__2_;
- MenhirLib.EngineTypes.endp = _endpos__2_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = _1;
- MenhirLib.EngineTypes.startp = _startpos__1_;
- MenhirLib.EngineTypes.endp = _endpos__1_;
- MenhirLib.EngineTypes.next = _menhir_stack;
- };
- };
- } = _menhir_stack in
- let _3 : (
-# 688 "parsing/parser.mly"
- (string)
-# 20374 "parsing/parser.ml"
- ) = Obj.magic _3 in
- let _2 : unit = Obj.magic _2 in
let _1 : (Longident.t) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
- let _endpos = _endpos__3_ in
+ let _endpos = _endpos__1_ in
let _v : (Longident.t) =
-# 3447 "parsing/parser.mly"
- ( Ldot(_1, _3) )
-# 20384 "parsing/parser.ml"
+# 3503 "parsing/parser.mly"
+ ( _1 )
+# 20927 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_me_ in
let _v : (Parsetree.module_expr) =
-# 1323 "parsing/parser.mly"
+# 1373 "parsing/parser.mly"
( me )
-# 20416 "parsing/parser.ml"
+# 20959 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos_me_ in
let _v : (Parsetree.module_expr) = let _1 =
let _1 =
-# 1326 "parsing/parser.mly"
+# 1376 "parsing/parser.mly"
( Pmod_constraint(me, mty) )
-# 20463 "parsing/parser.ml"
+# 21006 "parsing/parser.ml"
in
let _endpos__1_ = _endpos_me_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 835 "parsing/parser.mly"
+# 856 "parsing/parser.mly"
( mkmod ~loc:_sloc _1 )
-# 20472 "parsing/parser.ml"
+# 21015 "parsing/parser.ml"
in
-# 1329 "parsing/parser.mly"
+# 1379 "parsing/parser.mly"
( _1 )
-# 20478 "parsing/parser.ml"
+# 21021 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos_body_ in
let _v : (Parsetree.module_expr) = let _1 =
let _1 =
-# 1328 "parsing/parser.mly"
+# 1378 "parsing/parser.mly"
( Pmod_functor(arg, body) )
-# 20511 "parsing/parser.ml"
+# 21054 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_body_, _startpos_arg_) in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 835 "parsing/parser.mly"
+# 856 "parsing/parser.mly"
( mkmod ~loc:_sloc _1 )
-# 20520 "parsing/parser.ml"
+# 21063 "parsing/parser.ml"
in
-# 1329 "parsing/parser.mly"
+# 1379 "parsing/parser.mly"
( _1 )
-# 20526 "parsing/parser.ml"
+# 21069 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_mty_ in
let _v : (Parsetree.module_type) =
-# 1566 "parsing/parser.mly"
+# 1616 "parsing/parser.mly"
( mty )
-# 20558 "parsing/parser.ml"
+# 21101 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos_body_ in
let _v : (Parsetree.module_type) = let _1 =
let _1 =
-# 1569 "parsing/parser.mly"
+# 1619 "parsing/parser.mly"
( Pmty_functor(arg, body) )
-# 20591 "parsing/parser.ml"
+# 21134 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_body_, _startpos_arg_) in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 837 "parsing/parser.mly"
+# 858 "parsing/parser.mly"
( mkmty ~loc:_sloc _1 )
-# 20600 "parsing/parser.ml"
+# 21143 "parsing/parser.ml"
in
-# 1571 "parsing/parser.mly"
+# 1621 "parsing/parser.mly"
( _1 )
-# 20606 "parsing/parser.ml"
+# 21149 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.module_expr) = let attrs =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 20654 "parsing/parser.ml"
+# 21197 "parsing/parser.ml"
in
let _endpos = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1162 "parsing/parser.mly"
+# 1212 "parsing/parser.mly"
( mkmod ~loc:_sloc ~attrs (Pmod_structure s) )
-# 20663 "parsing/parser.ml"
+# 21206 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.module_expr) = let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 20711 "parsing/parser.ml"
+# 21254 "parsing/parser.ml"
in
let _loc__4_ = (_startpos__4_, _endpos__4_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1164 "parsing/parser.mly"
+# 1214 "parsing/parser.mly"
( unclosed "struct" _loc__1_ "end" _loc__4_ )
-# 20719 "parsing/parser.ml"
+# 21262 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.module_expr) = let args =
let _1 = _1_inlined2 in
-# 1128 "parsing/parser.mly"
+# 1178 "parsing/parser.mly"
( _1 )
-# 20774 "parsing/parser.ml"
+# 21317 "parsing/parser.ml"
in
let attrs =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 20782 "parsing/parser.ml"
+# 21325 "parsing/parser.ml"
in
let _endpos = _endpos_me_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1166 "parsing/parser.mly"
+# 1216 "parsing/parser.mly"
( wrap_mod_attrs ~loc:_sloc attrs (
List.fold_left (fun acc arg ->
mkmod ~loc:_sloc (Pmod_functor (arg, acc))
) me args
) )
-# 20795 "parsing/parser.ml"
+# 21338 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_me_ in
let _endpos = _endpos_me_ in
let _v : (Parsetree.module_expr) =
-# 1172 "parsing/parser.mly"
+# 1222 "parsing/parser.mly"
( me )
-# 20820 "parsing/parser.ml"
+# 21363 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_me_ in
let _endpos = _endpos_attr_ in
let _v : (Parsetree.module_expr) =
-# 1174 "parsing/parser.mly"
+# 1224 "parsing/parser.mly"
( Mod.attr me attr )
-# 20852 "parsing/parser.ml"
+# 21395 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 20883 "parsing/parser.ml"
+# 21426 "parsing/parser.ml"
in
-# 1178 "parsing/parser.mly"
+# 1228 "parsing/parser.mly"
( Pmod_ident x )
-# 20889 "parsing/parser.ml"
+# 21432 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 835 "parsing/parser.mly"
+# 856 "parsing/parser.mly"
( mkmod ~loc:_sloc _1 )
-# 20898 "parsing/parser.ml"
+# 21441 "parsing/parser.ml"
in
-# 1190 "parsing/parser.mly"
+# 1240 "parsing/parser.mly"
( _1 )
-# 20904 "parsing/parser.ml"
+# 21447 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos_me2_ in
let _v : (Parsetree.module_expr) = let _1 =
let _1 =
-# 1181 "parsing/parser.mly"
+# 1231 "parsing/parser.mly"
( Pmod_apply(me1, me2) )
-# 20937 "parsing/parser.ml"
+# 21480 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_me2_, _startpos_me1_) in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 835 "parsing/parser.mly"
+# 856 "parsing/parser.mly"
( mkmod ~loc:_sloc _1 )
-# 20946 "parsing/parser.ml"
+# 21489 "parsing/parser.ml"
in
-# 1190 "parsing/parser.mly"
+# 1240 "parsing/parser.mly"
( _1 )
-# 20952 "parsing/parser.ml"
+# 21495 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos_me1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1184 "parsing/parser.mly"
+# 1234 "parsing/parser.mly"
( (* TODO review mkmod location *)
Pmod_apply(me1, mkmod ~loc:_sloc (Pmod_structure [])) )
-# 20997 "parsing/parser.ml"
+# 21540 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos__3_, _startpos_me1_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 835 "parsing/parser.mly"
+# 856 "parsing/parser.mly"
( mkmod ~loc:_sloc _1 )
-# 21007 "parsing/parser.ml"
+# 21550 "parsing/parser.ml"
in
-# 1190 "parsing/parser.mly"
+# 1240 "parsing/parser.mly"
( _1 )
-# 21013 "parsing/parser.ml"
+# 21556 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos_ex_ in
let _v : (Parsetree.module_expr) = let _1 =
let _1 =
-# 1188 "parsing/parser.mly"
+# 1238 "parsing/parser.mly"
( Pmod_extension ex )
-# 21039 "parsing/parser.ml"
+# 21582 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_ex_, _startpos_ex_) in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 835 "parsing/parser.mly"
+# 856 "parsing/parser.mly"
( mkmod ~loc:_sloc _1 )
-# 21048 "parsing/parser.ml"
+# 21591 "parsing/parser.ml"
in
-# 1190 "parsing/parser.mly"
+# 1240 "parsing/parser.mly"
( _1 )
-# 21054 "parsing/parser.ml"
+# 21597 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let x : (
-# 688 "parsing/parser.mly"
+# 697 "parsing/parser.mly"
(string)
-# 21075 "parsing/parser.ml"
+# 21618 "parsing/parser.ml"
) = Obj.magic x in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : (string option) =
-# 1145 "parsing/parser.mly"
+# 1195 "parsing/parser.mly"
( Some x )
-# 21083 "parsing/parser.ml"
+# 21626 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string option) =
-# 1148 "parsing/parser.mly"
+# 1198 "parsing/parser.mly"
( None )
-# 21108 "parsing/parser.ml"
+# 21651 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined3 : (Longident.t) = Obj.magic _1_inlined3 in
let _5 : unit = Obj.magic _5 in
let _1_inlined2 : (
-# 688 "parsing/parser.mly"
+# 697 "parsing/parser.mly"
(string)
-# 21168 "parsing/parser.ml"
+# 21711 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
let ext : (string Asttypes.loc option) = Obj.magic ext in
let _v : (Parsetree.module_substitution * string Asttypes.loc option) = let attrs2 =
let _1 = _1_inlined4 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 21181 "parsing/parser.ml"
+# 21724 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 21193 "parsing/parser.ml"
+# 21736 "parsing/parser.ml"
in
let uid =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 21204 "parsing/parser.ml"
+# 21747 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 21212 "parsing/parser.ml"
+# 21755 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1601 "parsing/parser.mly"
+# 1651 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
let docs = symbol_docs _sloc in
Ms.mk uid body ~attrs ~loc ~docs, ext
)
-# 21226 "parsing/parser.ml"
+# 21769 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _6 : unit = Obj.magic _6 in
let _5 : unit = Obj.magic _5 in
let _1_inlined2 : (
-# 688 "parsing/parser.mly"
+# 697 "parsing/parser.mly"
(string)
-# 21279 "parsing/parser.ml"
+# 21822 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
let _2 : (string Asttypes.loc option) = Obj.magic _2 in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 21295 "parsing/parser.ml"
+# 21838 "parsing/parser.ml"
in
let _3 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 21303 "parsing/parser.ml"
+# 21846 "parsing/parser.ml"
in
let _loc__6_ = (_startpos__6_, _endpos__6_) in
-# 1608 "parsing/parser.mly"
+# 1658 "parsing/parser.mly"
( expecting _loc__6_ "module path" )
-# 21310 "parsing/parser.ml"
+# 21853 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.module_type) = let attrs =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 21358 "parsing/parser.ml"
+# 21901 "parsing/parser.ml"
in
let _endpos = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1454 "parsing/parser.mly"
+# 1504 "parsing/parser.mly"
( mkmty ~loc:_sloc ~attrs (Pmty_signature s) )
-# 21367 "parsing/parser.ml"
+# 21910 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.module_type) = let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 21415 "parsing/parser.ml"
+# 21958 "parsing/parser.ml"
in
let _loc__4_ = (_startpos__4_, _endpos__4_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1456 "parsing/parser.mly"
+# 1506 "parsing/parser.mly"
( unclosed "sig" _loc__1_ "end" _loc__4_ )
-# 21423 "parsing/parser.ml"
+# 21966 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.module_type) = let args =
let _1 = _1_inlined2 in
-# 1128 "parsing/parser.mly"
+# 1178 "parsing/parser.mly"
( _1 )
-# 21478 "parsing/parser.ml"
+# 22021 "parsing/parser.ml"
in
let attrs =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 21486 "parsing/parser.ml"
+# 22029 "parsing/parser.ml"
in
let _endpos = _endpos_mty_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1460 "parsing/parser.mly"
+# 1510 "parsing/parser.mly"
( wrap_mty_attrs ~loc:_sloc attrs (
List.fold_left (fun acc arg ->
mkmty ~loc:_sloc (Pmty_functor (arg, acc))
) mty args
) )
-# 21499 "parsing/parser.ml"
+# 22042 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.module_type) = let _4 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 21554 "parsing/parser.ml"
+# 22097 "parsing/parser.ml"
in
let _endpos = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1466 "parsing/parser.mly"
+# 1516 "parsing/parser.mly"
( mkmty ~loc:_sloc ~attrs:_4 (Pmty_typeof _5) )
-# 21563 "parsing/parser.ml"
+# 22106 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.module_type) =
-# 1468 "parsing/parser.mly"
+# 1518 "parsing/parser.mly"
( _2 )
-# 21602 "parsing/parser.ml"
+# 22145 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.module_type) = let _loc__3_ = (_startpos__3_, _endpos__3_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1470 "parsing/parser.mly"
+# 1520 "parsing/parser.mly"
( unclosed "(" _loc__1_ ")" _loc__3_ )
-# 21643 "parsing/parser.ml"
+# 22186 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.module_type) =
-# 1472 "parsing/parser.mly"
+# 1522 "parsing/parser.mly"
( Mty.attr _1 _2 )
-# 21675 "parsing/parser.ml"
+# 22218 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 21706 "parsing/parser.ml"
+# 22249 "parsing/parser.ml"
in
-# 1475 "parsing/parser.mly"
+# 1525 "parsing/parser.mly"
( Pmty_ident _1 )
-# 21712 "parsing/parser.ml"
+# 22255 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 837 "parsing/parser.mly"
+# 858 "parsing/parser.mly"
( mkmty ~loc:_sloc _1 )
-# 21721 "parsing/parser.ml"
+# 22264 "parsing/parser.ml"
in
-# 1486 "parsing/parser.mly"
+# 1536 "parsing/parser.mly"
( _1 )
-# 21727 "parsing/parser.ml"
+# 22270 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__3_ in
let _v : (Parsetree.module_type) = let _1 =
let _1 =
-# 1478 "parsing/parser.mly"
+# 1528 "parsing/parser.mly"
( Pmty_functor(Named (mknoloc None, _1), _3) )
-# 21767 "parsing/parser.ml"
+# 22310 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 837 "parsing/parser.mly"
+# 858 "parsing/parser.mly"
( mkmty ~loc:_sloc _1 )
-# 21776 "parsing/parser.ml"
+# 22319 "parsing/parser.ml"
in
-# 1486 "parsing/parser.mly"
+# 1536 "parsing/parser.mly"
( _1 )
-# 21782 "parsing/parser.ml"
+# 22325 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _3 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 21824 "parsing/parser.ml"
+# 22367 "parsing/parser.ml"
in
-# 926 "parsing/parser.mly"
+# 947 "parsing/parser.mly"
( xs )
-# 21829 "parsing/parser.ml"
+# 22372 "parsing/parser.ml"
in
-# 1480 "parsing/parser.mly"
+# 1530 "parsing/parser.mly"
( Pmty_with(_1, _3) )
-# 21835 "parsing/parser.ml"
+# 22378 "parsing/parser.ml"
in
let _endpos__1_ = _endpos_xs_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 837 "parsing/parser.mly"
+# 858 "parsing/parser.mly"
( mkmty ~loc:_sloc _1 )
-# 21845 "parsing/parser.ml"
+# 22388 "parsing/parser.ml"
in
-# 1486 "parsing/parser.mly"
+# 1536 "parsing/parser.mly"
( _1 )
-# 21851 "parsing/parser.ml"
+# 22394 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.module_type) = let _1 =
let _1 =
-# 1484 "parsing/parser.mly"
+# 1534 "parsing/parser.mly"
( Pmty_extension _1 )
-# 21877 "parsing/parser.ml"
+# 22420 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 837 "parsing/parser.mly"
+# 858 "parsing/parser.mly"
( mkmty ~loc:_sloc _1 )
-# 21885 "parsing/parser.ml"
+# 22428 "parsing/parser.ml"
in
-# 1486 "parsing/parser.mly"
+# 1536 "parsing/parser.mly"
( _1 )
-# 21891 "parsing/parser.ml"
+# 22434 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.module_type_declaration * string Asttypes.loc option) = let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 21960 "parsing/parser.ml"
+# 22503 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 21972 "parsing/parser.ml"
+# 22515 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 21980 "parsing/parser.ml"
+# 22523 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1400 "parsing/parser.mly"
+# 1450 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
let docs = symbol_docs _sloc in
Mtd.mk id ?typ ~attrs ~loc ~docs, ext
)
-# 21994 "parsing/parser.ml"
+# 22537 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.endp = _endpos__1_;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
- let _1 : (Asttypes.label) = Obj.magic _1 in
- let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
- let _startpos = _startpos__1_ in
- let _endpos = _endpos__1_ in
- let _v : (Longident.t) =
-# 3458 "parsing/parser.mly"
- ( Lident _1 )
-# 22019 "parsing/parser.ml"
- in
- {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = Obj.repr _v;
- MenhirLib.EngineTypes.startp = _startpos;
- MenhirLib.EngineTypes.endp = _endpos;
- MenhirLib.EngineTypes.next = _menhir_stack;
- });
- (fun _menhir_env ->
- let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
- let {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _3;
- MenhirLib.EngineTypes.startp = _startpos__3_;
- MenhirLib.EngineTypes.endp = _endpos__3_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _2;
- MenhirLib.EngineTypes.startp = _startpos__2_;
- MenhirLib.EngineTypes.endp = _endpos__2_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = _1;
- MenhirLib.EngineTypes.startp = _startpos__1_;
- MenhirLib.EngineTypes.endp = _endpos__1_;
- MenhirLib.EngineTypes.next = _menhir_stack;
- };
- };
- } = _menhir_stack in
- let _3 : (Asttypes.label) = Obj.magic _3 in
- let _2 : unit = Obj.magic _2 in
let _1 : (Longident.t) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
- let _endpos = _endpos__3_ in
+ let _endpos = _endpos__1_ in
let _v : (Longident.t) =
-# 3459 "parsing/parser.mly"
- ( Ldot(_1, _3) )
-# 22058 "parsing/parser.ml"
+# 3513 "parsing/parser.mly"
+ ( _1 )
+# 22562 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Asttypes.mutable_flag) =
-# 3528 "parsing/parser.mly"
+# 3590 "parsing/parser.mly"
( Immutable )
-# 22076 "parsing/parser.ml"
+# 22580 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.mutable_flag) =
-# 3529 "parsing/parser.mly"
+# 3591 "parsing/parser.mly"
( Mutable )
-# 22101 "parsing/parser.ml"
+# 22605 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) =
-# 3537 "parsing/parser.mly"
+# 3599 "parsing/parser.mly"
( Immutable, Concrete )
-# 22119 "parsing/parser.ml"
+# 22623 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) =
-# 3539 "parsing/parser.mly"
+# 3601 "parsing/parser.mly"
( Mutable, Concrete )
-# 22144 "parsing/parser.ml"
+# 22648 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) =
-# 3541 "parsing/parser.mly"
+# 3603 "parsing/parser.mly"
( Immutable, Virtual )
-# 22169 "parsing/parser.ml"
+# 22673 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) =
-# 3544 "parsing/parser.mly"
+# 3606 "parsing/parser.mly"
( Mutable, Virtual )
-# 22201 "parsing/parser.ml"
+# 22705 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) =
-# 3544 "parsing/parser.mly"
+# 3606 "parsing/parser.mly"
( Mutable, Virtual )
-# 22233 "parsing/parser.ml"
+# 22737 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Asttypes.label) =
-# 3501 "parsing/parser.mly"
+# 3563 "parsing/parser.mly"
( _2 )
-# 22265 "parsing/parser.ml"
+# 22769 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 22286 "parsing/parser.ml"
+# 22790 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 22298 "parsing/parser.ml"
+# 22802 "parsing/parser.ml"
in
-# 221 "menhir/standard.mly"
+# 221 "<standard.mly>"
( [ x ] )
-# 22304 "parsing/parser.ml"
+# 22808 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let xs : (string Asttypes.loc list) = Obj.magic xs in
let _1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 22332 "parsing/parser.ml"
+# 22836 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 22344 "parsing/parser.ml"
+# 22848 "parsing/parser.ml"
in
-# 223 "menhir/standard.mly"
+# 223 "<standard.mly>"
( x :: xs )
-# 22350 "parsing/parser.ml"
+# 22854 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let s : (
-# 680 "parsing/parser.mly"
- (string * string option)
-# 22371 "parsing/parser.ml"
+# 685 "parsing/parser.mly"
+ (string * Location.t * string option)
+# 22875 "parsing/parser.ml"
) = Obj.magic s in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos_s_ in
let _endpos = _endpos_s_ in
let _v : (string list) = let x =
-# 3497 "parsing/parser.mly"
- ( fst s )
-# 22379 "parsing/parser.ml"
+# 3559 "parsing/parser.mly"
+ ( let body, _, _ = s in body )
+# 22883 "parsing/parser.ml"
in
-# 221 "menhir/standard.mly"
+# 221 "<standard.mly>"
( [ x ] )
-# 22384 "parsing/parser.ml"
+# 22888 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let xs : (string list) = Obj.magic xs in
let s : (
-# 680 "parsing/parser.mly"
- (string * string option)
-# 22412 "parsing/parser.ml"
+# 685 "parsing/parser.mly"
+ (string * Location.t * string option)
+# 22916 "parsing/parser.ml"
) = Obj.magic s in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos_s_ in
let _endpos = _endpos_xs_ in
let _v : (string list) = let x =
-# 3497 "parsing/parser.mly"
- ( fst s )
-# 22420 "parsing/parser.ml"
+# 3559 "parsing/parser.mly"
+ ( let body, _, _ = s in body )
+# 22924 "parsing/parser.ml"
in
-# 223 "menhir/standard.mly"
+# 223 "<standard.mly>"
( x :: xs )
-# 22425 "parsing/parser.ml"
+# 22929 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_ty_ in
let _endpos = _endpos_ty_ in
let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv =
-# 3524 "parsing/parser.mly"
+# 3586 "parsing/parser.mly"
( Public )
-# 22450 "parsing/parser.ml"
+# 22954 "parsing/parser.ml"
in
-# 2846 "parsing/parser.mly"
+# 2896 "parsing/parser.mly"
( (Ptype_abstract, priv, Some ty) )
-# 22455 "parsing/parser.ml"
+# 22959 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_ty_ in
let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv =
-# 3525 "parsing/parser.mly"
+# 3587 "parsing/parser.mly"
( Private )
-# 22487 "parsing/parser.ml"
+# 22991 "parsing/parser.ml"
in
-# 2846 "parsing/parser.mly"
+# 2896 "parsing/parser.mly"
( (Ptype_abstract, priv, Some ty) )
-# 22492 "parsing/parser.ml"
+# 22996 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_cs_ in
let _endpos = _endpos_cs_ in
let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv =
-# 3524 "parsing/parser.mly"
+# 3586 "parsing/parser.mly"
( Public )
-# 22517 "parsing/parser.ml"
+# 23021 "parsing/parser.ml"
in
let oty =
let _1 =
-# 124 "menhir/standard.mly"
+# 124 "<standard.mly>"
( None )
-# 22523 "parsing/parser.ml"
+# 23027 "parsing/parser.ml"
in
-# 2862 "parsing/parser.mly"
+# 2912 "parsing/parser.mly"
( _1 )
-# 22528 "parsing/parser.ml"
+# 23032 "parsing/parser.ml"
in
-# 2850 "parsing/parser.mly"
+# 2900 "parsing/parser.mly"
( (Ptype_variant cs, priv, oty) )
-# 22534 "parsing/parser.ml"
+# 23038 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_cs_ in
let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv =
-# 3525 "parsing/parser.mly"
+# 3587 "parsing/parser.mly"
( Private )
-# 22566 "parsing/parser.ml"
+# 23070 "parsing/parser.ml"
in
let oty =
let _1 =
-# 124 "menhir/standard.mly"
+# 124 "<standard.mly>"
( None )
-# 22572 "parsing/parser.ml"
+# 23076 "parsing/parser.ml"
in
-# 2862 "parsing/parser.mly"
+# 2912 "parsing/parser.mly"
( _1 )
-# 22577 "parsing/parser.ml"
+# 23081 "parsing/parser.ml"
in
-# 2850 "parsing/parser.mly"
+# 2900 "parsing/parser.mly"
( (Ptype_variant cs, priv, oty) )
-# 22583 "parsing/parser.ml"
+# 23087 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_cs_ in
let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv =
-# 3524 "parsing/parser.mly"
+# 3586 "parsing/parser.mly"
( Public )
-# 22622 "parsing/parser.ml"
+# 23126 "parsing/parser.ml"
in
let oty =
let _1 =
let x =
-# 191 "menhir/standard.mly"
+# 191 "<standard.mly>"
( x )
-# 22629 "parsing/parser.ml"
+# 23133 "parsing/parser.ml"
in
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 22634 "parsing/parser.ml"
+# 23138 "parsing/parser.ml"
in
-# 2862 "parsing/parser.mly"
+# 2912 "parsing/parser.mly"
( _1 )
-# 22640 "parsing/parser.ml"
+# 23144 "parsing/parser.ml"
in
-# 2850 "parsing/parser.mly"
+# 2900 "parsing/parser.mly"
( (Ptype_variant cs, priv, oty) )
-# 22646 "parsing/parser.ml"
+# 23150 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_cs_ in
let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv =
-# 3525 "parsing/parser.mly"
+# 3587 "parsing/parser.mly"
( Private )
-# 22692 "parsing/parser.ml"
+# 23196 "parsing/parser.ml"
in
let oty =
let _1 =
let x =
-# 191 "menhir/standard.mly"
+# 191 "<standard.mly>"
( x )
-# 22699 "parsing/parser.ml"
+# 23203 "parsing/parser.ml"
in
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 22704 "parsing/parser.ml"
+# 23208 "parsing/parser.ml"
in
-# 2862 "parsing/parser.mly"
+# 2912 "parsing/parser.mly"
( _1 )
-# 22710 "parsing/parser.ml"
+# 23214 "parsing/parser.ml"
in
-# 2850 "parsing/parser.mly"
+# 2900 "parsing/parser.mly"
( (Ptype_variant cs, priv, oty) )
-# 22716 "parsing/parser.ml"
+# 23220 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__3_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv =
-# 3524 "parsing/parser.mly"
+# 3586 "parsing/parser.mly"
( Public )
-# 22741 "parsing/parser.ml"
+# 23245 "parsing/parser.ml"
in
let oty =
let _1 =
-# 124 "menhir/standard.mly"
+# 124 "<standard.mly>"
( None )
-# 22747 "parsing/parser.ml"
+# 23251 "parsing/parser.ml"
in
-# 2862 "parsing/parser.mly"
+# 2912 "parsing/parser.mly"
( _1 )
-# 22752 "parsing/parser.ml"
+# 23256 "parsing/parser.ml"
in
-# 2854 "parsing/parser.mly"
+# 2904 "parsing/parser.mly"
( (Ptype_open, priv, oty) )
-# 22758 "parsing/parser.ml"
+# 23262 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv =
-# 3525 "parsing/parser.mly"
+# 3587 "parsing/parser.mly"
( Private )
-# 22790 "parsing/parser.ml"
+# 23294 "parsing/parser.ml"
in
let oty =
let _1 =
-# 124 "menhir/standard.mly"
+# 124 "<standard.mly>"
( None )
-# 22796 "parsing/parser.ml"
+# 23300 "parsing/parser.ml"
in
-# 2862 "parsing/parser.mly"
+# 2912 "parsing/parser.mly"
( _1 )
-# 22801 "parsing/parser.ml"
+# 23305 "parsing/parser.ml"
in
-# 2854 "parsing/parser.mly"
+# 2904 "parsing/parser.mly"
( (Ptype_open, priv, oty) )
-# 22807 "parsing/parser.ml"
+# 23311 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv =
-# 3524 "parsing/parser.mly"
+# 3586 "parsing/parser.mly"
( Public )
-# 22846 "parsing/parser.ml"
+# 23350 "parsing/parser.ml"
in
let oty =
let _1 =
let x =
-# 191 "menhir/standard.mly"
+# 191 "<standard.mly>"
( x )
-# 22853 "parsing/parser.ml"
+# 23357 "parsing/parser.ml"
in
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 22858 "parsing/parser.ml"
+# 23362 "parsing/parser.ml"
in
-# 2862 "parsing/parser.mly"
+# 2912 "parsing/parser.mly"
( _1 )
-# 22864 "parsing/parser.ml"
+# 23368 "parsing/parser.ml"
in
-# 2854 "parsing/parser.mly"
+# 2904 "parsing/parser.mly"
( (Ptype_open, priv, oty) )
-# 22870 "parsing/parser.ml"
+# 23374 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv =
-# 3525 "parsing/parser.mly"
+# 3587 "parsing/parser.mly"
( Private )
-# 22916 "parsing/parser.ml"
+# 23420 "parsing/parser.ml"
in
let oty =
let _1 =
let x =
-# 191 "menhir/standard.mly"
+# 191 "<standard.mly>"
( x )
-# 22923 "parsing/parser.ml"
+# 23427 "parsing/parser.ml"
in
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 22928 "parsing/parser.ml"
+# 23432 "parsing/parser.ml"
in
-# 2862 "parsing/parser.mly"
+# 2912 "parsing/parser.mly"
( _1 )
-# 22934 "parsing/parser.ml"
+# 23438 "parsing/parser.ml"
in
-# 2854 "parsing/parser.mly"
+# 2904 "parsing/parser.mly"
( (Ptype_open, priv, oty) )
-# 22940 "parsing/parser.ml"
+# 23444 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__3_ in
let _endpos = _endpos__5_ in
let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv =
-# 3524 "parsing/parser.mly"
+# 3586 "parsing/parser.mly"
( Public )
-# 22979 "parsing/parser.ml"
+# 23483 "parsing/parser.ml"
in
let oty =
let _1 =
-# 124 "menhir/standard.mly"
+# 124 "<standard.mly>"
( None )
-# 22985 "parsing/parser.ml"
+# 23489 "parsing/parser.ml"
in
-# 2862 "parsing/parser.mly"
+# 2912 "parsing/parser.mly"
( _1 )
-# 22990 "parsing/parser.ml"
+# 23494 "parsing/parser.ml"
in
-# 2858 "parsing/parser.mly"
+# 2908 "parsing/parser.mly"
( (Ptype_record ls, priv, oty) )
-# 22996 "parsing/parser.ml"
+# 23500 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv =
-# 3525 "parsing/parser.mly"
+# 3587 "parsing/parser.mly"
( Private )
-# 23042 "parsing/parser.ml"
+# 23546 "parsing/parser.ml"
in
let oty =
let _1 =
-# 124 "menhir/standard.mly"
+# 124 "<standard.mly>"
( None )
-# 23048 "parsing/parser.ml"
+# 23552 "parsing/parser.ml"
in
-# 2862 "parsing/parser.mly"
+# 2912 "parsing/parser.mly"
( _1 )
-# 23053 "parsing/parser.ml"
+# 23557 "parsing/parser.ml"
in
-# 2858 "parsing/parser.mly"
+# 2908 "parsing/parser.mly"
( (Ptype_record ls, priv, oty) )
-# 23059 "parsing/parser.ml"
+# 23563 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos__5_ in
let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv =
-# 3524 "parsing/parser.mly"
+# 3586 "parsing/parser.mly"
( Public )
-# 23112 "parsing/parser.ml"
+# 23616 "parsing/parser.ml"
in
let oty =
let _1 =
let x =
-# 191 "menhir/standard.mly"
+# 191 "<standard.mly>"
( x )
-# 23119 "parsing/parser.ml"
+# 23623 "parsing/parser.ml"
in
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 23124 "parsing/parser.ml"
+# 23628 "parsing/parser.ml"
in
-# 2862 "parsing/parser.mly"
+# 2912 "parsing/parser.mly"
( _1 )
-# 23130 "parsing/parser.ml"
+# 23634 "parsing/parser.ml"
in
-# 2858 "parsing/parser.mly"
+# 2908 "parsing/parser.mly"
( (Ptype_record ls, priv, oty) )
-# 23136 "parsing/parser.ml"
+# 23640 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos__5_ in
let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv =
-# 3525 "parsing/parser.mly"
+# 3587 "parsing/parser.mly"
( Private )
-# 23196 "parsing/parser.ml"
+# 23700 "parsing/parser.ml"
in
let oty =
let _1 =
let x =
-# 191 "menhir/standard.mly"
+# 191 "<standard.mly>"
( x )
-# 23203 "parsing/parser.ml"
+# 23707 "parsing/parser.ml"
in
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 23208 "parsing/parser.ml"
+# 23712 "parsing/parser.ml"
in
-# 2862 "parsing/parser.mly"
+# 2912 "parsing/parser.mly"
( _1 )
-# 23214 "parsing/parser.ml"
+# 23718 "parsing/parser.ml"
in
-# 2858 "parsing/parser.mly"
+# 2908 "parsing/parser.mly"
( (Ptype_record ls, priv, oty) )
-# 23220 "parsing/parser.ml"
+# 23724 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.open_declaration * string Asttypes.loc option) = let attrs2 =
let _1 = _1_inlined2 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 23275 "parsing/parser.ml"
+# 23779 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined2_ in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 23284 "parsing/parser.ml"
+# 23788 "parsing/parser.ml"
in
let override =
-# 3571 "parsing/parser.mly"
+# 3633 "parsing/parser.mly"
( Fresh )
-# 23290 "parsing/parser.ml"
+# 23794 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1419 "parsing/parser.mly"
+# 1469 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
let docs = symbol_docs _sloc in
Opn.mk me ~override ~attrs ~loc ~docs, ext
)
-# 23303 "parsing/parser.ml"
+# 23807 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.open_declaration * string Asttypes.loc option) = let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 23365 "parsing/parser.ml"
+# 23869 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let attrs1 =
let _1 = _1_inlined2 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 23374 "parsing/parser.ml"
+# 23878 "parsing/parser.ml"
in
let override =
let _1 = _1_inlined1 in
-# 3572 "parsing/parser.mly"
+# 3634 "parsing/parser.mly"
( Override )
-# 23382 "parsing/parser.ml"
+# 23886 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1419 "parsing/parser.mly"
+# 1469 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
let docs = symbol_docs _sloc in
Opn.mk me ~override ~attrs ~loc ~docs, ext
)
-# 23396 "parsing/parser.ml"
+# 23900 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.open_description * string Asttypes.loc option) = let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 23451 "parsing/parser.ml"
+# 23955 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 23463 "parsing/parser.ml"
+# 23967 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 23471 "parsing/parser.ml"
+# 23975 "parsing/parser.ml"
in
let override =
-# 3571 "parsing/parser.mly"
+# 3633 "parsing/parser.mly"
( Fresh )
-# 23477 "parsing/parser.ml"
+# 23981 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1434 "parsing/parser.mly"
+# 1484 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
let docs = symbol_docs _sloc in
Opn.mk id ~override ~attrs ~loc ~docs, ext
)
-# 23490 "parsing/parser.ml"
+# 23994 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.open_description * string Asttypes.loc option) = let attrs2 =
let _1 = _1_inlined4 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 23552 "parsing/parser.ml"
+# 24056 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 23564 "parsing/parser.ml"
+# 24068 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined2 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 23572 "parsing/parser.ml"
+# 24076 "parsing/parser.ml"
in
let override =
let _1 = _1_inlined1 in
-# 3572 "parsing/parser.mly"
+# 3634 "parsing/parser.mly"
( Override )
-# 23580 "parsing/parser.ml"
+# 24084 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1434 "parsing/parser.mly"
+# 1484 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
let docs = symbol_docs _sloc in
Opn.mk id ~override ~attrs ~loc ~docs, ext
)
-# 23594 "parsing/parser.ml"
+# 24098 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 666 "parsing/parser.mly"
+# 671 "parsing/parser.mly"
(string)
-# 23615 "parsing/parser.ml"
+# 24119 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) =
-# 3376 "parsing/parser.mly"
+ let _v : (Asttypes.label) =
+# 3429 "parsing/parser.mly"
( _1 )
-# 23623 "parsing/parser.ml"
+# 24127 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 624 "parsing/parser.mly"
+# 629 "parsing/parser.mly"
(string)
-# 23644 "parsing/parser.ml"
+# 24148 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) =
-# 3377 "parsing/parser.mly"
+ let _v : (Asttypes.label) =
+# 3430 "parsing/parser.mly"
( _1 )
-# 23652 "parsing/parser.ml"
+# 24156 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 625 "parsing/parser.mly"
+# 630 "parsing/parser.mly"
(string)
-# 23673 "parsing/parser.ml"
+# 24177 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) =
-# 3378 "parsing/parser.mly"
+ let _v : (Asttypes.label) =
+# 3431 "parsing/parser.mly"
( _1 )
-# 23681 "parsing/parser.ml"
+# 24185 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 : (string) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _1 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 23723 "parsing/parser.ml"
+# 24227 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
- let _v : (string) =
-# 3379 "parsing/parser.mly"
+ let _v : (Asttypes.label) =
+# 3432 "parsing/parser.mly"
( "."^ _1 ^"(" ^ _3 ^ ")" )
-# 23731 "parsing/parser.ml"
+# 24235 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 : (string) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _1 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 23780 "parsing/parser.ml"
+# 24284 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
- let _v : (string) =
-# 3380 "parsing/parser.mly"
+ let _v : (Asttypes.label) =
+# 3433 "parsing/parser.mly"
( "."^ _1 ^ "(" ^ _3 ^ ")<-" )
-# 23788 "parsing/parser.ml"
+# 24292 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 : (string) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _1 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 23830 "parsing/parser.ml"
+# 24334 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
- let _v : (string) =
-# 3381 "parsing/parser.mly"
+ let _v : (Asttypes.label) =
+# 3434 "parsing/parser.mly"
( "."^ _1 ^"[" ^ _3 ^ "]" )
-# 23838 "parsing/parser.ml"
+# 24342 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 : (string) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _1 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 23887 "parsing/parser.ml"
+# 24391 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
- let _v : (string) =
-# 3382 "parsing/parser.mly"
+ let _v : (Asttypes.label) =
+# 3435 "parsing/parser.mly"
( "."^ _1 ^ "[" ^ _3 ^ "]<-" )
-# 23895 "parsing/parser.ml"
+# 24399 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 : (string) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _1 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 23937 "parsing/parser.ml"
+# 24441 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
- let _v : (string) =
-# 3383 "parsing/parser.mly"
+ let _v : (Asttypes.label) =
+# 3436 "parsing/parser.mly"
( "."^ _1 ^"{" ^ _3 ^ "}" )
-# 23945 "parsing/parser.ml"
+# 24449 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 : (string) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _1 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 23994 "parsing/parser.ml"
+# 24498 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
- let _v : (string) =
-# 3384 "parsing/parser.mly"
+ let _v : (Asttypes.label) =
+# 3437 "parsing/parser.mly"
( "."^ _1 ^ "{" ^ _3 ^ "}<-" )
-# 24002 "parsing/parser.ml"
+# 24506 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 677 "parsing/parser.mly"
+# 682 "parsing/parser.mly"
(string)
-# 24023 "parsing/parser.ml"
+# 24527 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) =
-# 3385 "parsing/parser.mly"
+ let _v : (Asttypes.label) =
+# 3438 "parsing/parser.mly"
( _1 )
-# 24031 "parsing/parser.ml"
+# 24535 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) =
-# 3386 "parsing/parser.mly"
+ let _v : (Asttypes.label) =
+# 3439 "parsing/parser.mly"
( "!" )
-# 24056 "parsing/parser.ml"
+# 24560 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let op : (
-# 618 "parsing/parser.mly"
+# 623 "parsing/parser.mly"
(string)
-# 24077 "parsing/parser.ml"
+# 24581 "parsing/parser.ml"
) = Obj.magic op in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos_op_ in
let _endpos = _endpos_op_ in
- let _v : (string) = let _1 =
-# 3390 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3443 "parsing/parser.mly"
( op )
-# 24085 "parsing/parser.ml"
+# 24589 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24090 "parsing/parser.ml"
+# 24594 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let op : (
-# 619 "parsing/parser.mly"
+# 624 "parsing/parser.mly"
(string)
-# 24111 "parsing/parser.ml"
+# 24615 "parsing/parser.ml"
) = Obj.magic op in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos_op_ in
let _endpos = _endpos_op_ in
- let _v : (string) = let _1 =
-# 3391 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3444 "parsing/parser.mly"
( op )
-# 24119 "parsing/parser.ml"
+# 24623 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24124 "parsing/parser.ml"
+# 24628 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let op : (
-# 620 "parsing/parser.mly"
+# 625 "parsing/parser.mly"
(string)
-# 24145 "parsing/parser.ml"
+# 24649 "parsing/parser.ml"
) = Obj.magic op in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos_op_ in
let _endpos = _endpos_op_ in
- let _v : (string) = let _1 =
-# 3392 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3445 "parsing/parser.mly"
( op )
-# 24153 "parsing/parser.ml"
+# 24657 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24158 "parsing/parser.ml"
+# 24662 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let op : (
-# 621 "parsing/parser.mly"
+# 626 "parsing/parser.mly"
(string)
-# 24179 "parsing/parser.ml"
+# 24683 "parsing/parser.ml"
) = Obj.magic op in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos_op_ in
let _endpos = _endpos_op_ in
- let _v : (string) = let _1 =
-# 3393 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3446 "parsing/parser.mly"
( op )
-# 24187 "parsing/parser.ml"
+# 24691 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24192 "parsing/parser.ml"
+# 24696 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let op : (
-# 622 "parsing/parser.mly"
+# 627 "parsing/parser.mly"
(string)
-# 24213 "parsing/parser.ml"
+# 24717 "parsing/parser.ml"
) = Obj.magic op in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos_op_ in
let _endpos = _endpos_op_ in
- let _v : (string) = let _1 =
-# 3394 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3447 "parsing/parser.mly"
( op )
-# 24221 "parsing/parser.ml"
+# 24725 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24226 "parsing/parser.ml"
+# 24730 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) = let _1 =
-# 3395 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3448 "parsing/parser.mly"
("+")
-# 24251 "parsing/parser.ml"
+# 24755 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24256 "parsing/parser.ml"
+# 24760 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) = let _1 =
-# 3396 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3449 "parsing/parser.mly"
("+.")
-# 24281 "parsing/parser.ml"
+# 24785 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24286 "parsing/parser.ml"
+# 24790 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) = let _1 =
-# 3397 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3450 "parsing/parser.mly"
("+=")
-# 24311 "parsing/parser.ml"
+# 24815 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24316 "parsing/parser.ml"
+# 24820 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) = let _1 =
-# 3398 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3451 "parsing/parser.mly"
("-")
-# 24341 "parsing/parser.ml"
+# 24845 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24346 "parsing/parser.ml"
+# 24850 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) = let _1 =
-# 3399 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3452 "parsing/parser.mly"
("-.")
-# 24371 "parsing/parser.ml"
+# 24875 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24376 "parsing/parser.ml"
+# 24880 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) = let _1 =
-# 3400 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3453 "parsing/parser.mly"
("*")
-# 24401 "parsing/parser.ml"
+# 24905 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24406 "parsing/parser.ml"
+# 24910 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) = let _1 =
-# 3401 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3454 "parsing/parser.mly"
("%")
-# 24431 "parsing/parser.ml"
+# 24935 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24436 "parsing/parser.ml"
+# 24940 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) = let _1 =
-# 3402 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3455 "parsing/parser.mly"
("=")
-# 24461 "parsing/parser.ml"
+# 24965 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24466 "parsing/parser.ml"
+# 24970 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) = let _1 =
-# 3403 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3456 "parsing/parser.mly"
("<")
-# 24491 "parsing/parser.ml"
+# 24995 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24496 "parsing/parser.ml"
+# 25000 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) = let _1 =
-# 3404 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3457 "parsing/parser.mly"
(">")
-# 24521 "parsing/parser.ml"
+# 25025 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24526 "parsing/parser.ml"
+# 25030 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) = let _1 =
-# 3405 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3458 "parsing/parser.mly"
("or")
-# 24551 "parsing/parser.ml"
+# 25055 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24556 "parsing/parser.ml"
+# 25060 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) = let _1 =
-# 3406 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3459 "parsing/parser.mly"
("||")
-# 24581 "parsing/parser.ml"
+# 25085 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24586 "parsing/parser.ml"
+# 25090 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) = let _1 =
-# 3407 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3460 "parsing/parser.mly"
("&")
-# 24611 "parsing/parser.ml"
+# 25115 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24616 "parsing/parser.ml"
+# 25120 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) = let _1 =
-# 3408 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3461 "parsing/parser.mly"
("&&")
-# 24641 "parsing/parser.ml"
+# 25145 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24646 "parsing/parser.ml"
+# 25150 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (string) = let _1 =
-# 3409 "parsing/parser.mly"
+ let _v : (Asttypes.label) = let _1 =
+# 3462 "parsing/parser.mly"
(":=")
-# 24671 "parsing/parser.ml"
+# 25175 "parsing/parser.ml"
in
-# 3387 "parsing/parser.mly"
+# 3440 "parsing/parser.mly"
( _1 )
-# 24676 "parsing/parser.ml"
+# 25180 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (bool) =
-# 3294 "parsing/parser.mly"
+# 3344 "parsing/parser.mly"
( true )
-# 24701 "parsing/parser.ml"
+# 25205 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (bool) =
-# 3295 "parsing/parser.mly"
+# 3345 "parsing/parser.mly"
( false )
-# 24719 "parsing/parser.ml"
+# 25223 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (unit option) =
-# 114 "menhir/standard.mly"
+# 114 "<standard.mly>"
( None )
-# 24737 "parsing/parser.ml"
+# 25241 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : (unit option) =
-# 116 "menhir/standard.mly"
+# 116 "<standard.mly>"
( Some x )
-# 24762 "parsing/parser.ml"
+# 25266 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (unit option) =
-# 114 "menhir/standard.mly"
+# 114 "<standard.mly>"
( None )
-# 24780 "parsing/parser.ml"
+# 25284 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : (unit option) =
-# 116 "menhir/standard.mly"
+# 116 "<standard.mly>"
( Some x )
-# 24805 "parsing/parser.ml"
+# 25309 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (string Asttypes.loc option) =
-# 114 "menhir/standard.mly"
+# 114 "<standard.mly>"
( None )
-# 24823 "parsing/parser.ml"
+# 25327 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _1_inlined1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 24850 "parsing/parser.ml"
+# 25354 "parsing/parser.ml"
) = Obj.magic _1_inlined1 in
let _1 : unit = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 24865 "parsing/parser.ml"
+# 25369 "parsing/parser.ml"
in
-# 183 "menhir/standard.mly"
+# 183 "<standard.mly>"
( x )
-# 24871 "parsing/parser.ml"
+# 25375 "parsing/parser.ml"
in
-# 116 "menhir/standard.mly"
+# 116 "<standard.mly>"
( Some x )
-# 24877 "parsing/parser.ml"
+# 25381 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.core_type option) =
-# 114 "menhir/standard.mly"
+# 114 "<standard.mly>"
( None )
-# 24895 "parsing/parser.ml"
+# 25399 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.core_type option) = let x =
-# 183 "menhir/standard.mly"
+# 183 "<standard.mly>"
( x )
-# 24927 "parsing/parser.ml"
+# 25431 "parsing/parser.ml"
in
-# 116 "menhir/standard.mly"
+# 116 "<standard.mly>"
( Some x )
-# 24932 "parsing/parser.ml"
+# 25436 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.expression option) =
-# 114 "menhir/standard.mly"
+# 114 "<standard.mly>"
( None )
-# 24950 "parsing/parser.ml"
+# 25454 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.expression option) = let x =
-# 183 "menhir/standard.mly"
+# 183 "<standard.mly>"
( x )
-# 24982 "parsing/parser.ml"
+# 25486 "parsing/parser.ml"
in
-# 116 "menhir/standard.mly"
+# 116 "<standard.mly>"
( Some x )
-# 24987 "parsing/parser.ml"
+# 25491 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.module_type option) =
-# 114 "menhir/standard.mly"
+# 114 "<standard.mly>"
( None )
-# 25005 "parsing/parser.ml"
+# 25509 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.module_type option) = let x =
-# 183 "menhir/standard.mly"
+# 183 "<standard.mly>"
( x )
-# 25037 "parsing/parser.ml"
+# 25541 "parsing/parser.ml"
in
-# 116 "menhir/standard.mly"
+# 116 "<standard.mly>"
( Some x )
-# 25042 "parsing/parser.ml"
+# 25546 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.pattern option) =
-# 114 "menhir/standard.mly"
+# 114 "<standard.mly>"
( None )
-# 25060 "parsing/parser.ml"
+# 25564 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.pattern option) = let x =
-# 183 "menhir/standard.mly"
+# 183 "<standard.mly>"
( x )
-# 25092 "parsing/parser.ml"
+# 25596 "parsing/parser.ml"
in
-# 116 "menhir/standard.mly"
+# 116 "<standard.mly>"
( Some x )
-# 25097 "parsing/parser.ml"
+# 25601 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.expression option) =
-# 114 "menhir/standard.mly"
+# 114 "<standard.mly>"
( None )
-# 25115 "parsing/parser.ml"
+# 25619 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.expression option) = let x =
-# 183 "menhir/standard.mly"
+# 183 "<standard.mly>"
( x )
-# 25147 "parsing/parser.ml"
+# 25651 "parsing/parser.ml"
in
-# 116 "menhir/standard.mly"
+# 116 "<standard.mly>"
( Some x )
-# 25152 "parsing/parser.ml"
+# 25656 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : ((Parsetree.core_type option * Parsetree.core_type option) option) =
-# 114 "menhir/standard.mly"
+# 114 "<standard.mly>"
( None )
-# 25170 "parsing/parser.ml"
+# 25674 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : ((Parsetree.core_type option * Parsetree.core_type option) option) =
-# 116 "menhir/standard.mly"
+# 116 "<standard.mly>"
( Some x )
-# 25195 "parsing/parser.ml"
+# 25699 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 659 "parsing/parser.mly"
+# 664 "parsing/parser.mly"
(string)
-# 25216 "parsing/parser.ml"
+# 25720 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3583 "parsing/parser.mly"
+# 3645 "parsing/parser.mly"
( _1 )
-# 25224 "parsing/parser.ml"
+# 25728 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : unit = Obj.magic _3 in
let _2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 25258 "parsing/parser.ml"
+# 25762 "parsing/parser.ml"
) = Obj.magic _2 in
let _1 : unit = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (string) =
-# 3584 "parsing/parser.mly"
+# 3646 "parsing/parser.mly"
( _2 )
-# 25267 "parsing/parser.ml"
+# 25771 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1199 "parsing/parser.mly"
+# 1249 "parsing/parser.mly"
( mkmod ~loc:_sloc (Pmod_constraint(me, mty)) )
-# 25323 "parsing/parser.ml"
+# 25827 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.module_expr) = let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1201 "parsing/parser.mly"
+# 1251 "parsing/parser.mly"
( unclosed "(" _loc__1_ ")" _loc__5_ )
-# 25378 "parsing/parser.ml"
+# 25882 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.module_expr) =
-# 1204 "parsing/parser.mly"
+# 1254 "parsing/parser.mly"
( me (* TODO consider reloc *) )
-# 25417 "parsing/parser.ml"
+# 25921 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.module_expr) = let _loc__3_ = (_startpos__3_, _endpos__3_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1206 "parsing/parser.mly"
+# 1256 "parsing/parser.mly"
( unclosed "(" _loc__1_ ")" _loc__3_ )
-# 25458 "parsing/parser.ml"
+# 25962 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : (Parsetree.module_expr) = let e =
-# 1223 "parsing/parser.mly"
+# 1273 "parsing/parser.mly"
( e )
-# 25511 "parsing/parser.ml"
+# 26015 "parsing/parser.ml"
in
let attrs =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 25518 "parsing/parser.ml"
+# 26022 "parsing/parser.ml"
in
let _endpos = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1210 "parsing/parser.mly"
+# 1260 "parsing/parser.mly"
( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) )
-# 25527 "parsing/parser.ml"
+# 26031 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let ty =
let _1 =
let _1 =
-# 3270 "parsing/parser.mly"
+# 3320 "parsing/parser.mly"
( Ptyp_package (package_type_of_module_type _1) )
-# 25598 "parsing/parser.ml"
+# 26102 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 25606 "parsing/parser.ml"
+# 26110 "parsing/parser.ml"
in
-# 3271 "parsing/parser.mly"
+# 3321 "parsing/parser.mly"
( _1 )
-# 25612 "parsing/parser.ml"
+# 26116 "parsing/parser.ml"
in
let _endpos_ty_ = _endpos__1_ in
let _startpos = _startpos_e_ in
let _loc = (_startpos, _endpos) in
-# 1225 "parsing/parser.mly"
+# 1275 "parsing/parser.mly"
( ghexp ~loc:_loc (Pexp_constraint (e, ty)) )
-# 25622 "parsing/parser.ml"
+# 26126 "parsing/parser.ml"
in
let attrs =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 25630 "parsing/parser.ml"
+# 26134 "parsing/parser.ml"
in
let _endpos = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1210 "parsing/parser.mly"
+# 1260 "parsing/parser.mly"
( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) )
-# 25639 "parsing/parser.ml"
+# 26143 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in
let _1 =
let _1 =
-# 3270 "parsing/parser.mly"
+# 3320 "parsing/parser.mly"
( Ptyp_package (package_type_of_module_type _1) )
-# 25725 "parsing/parser.ml"
+# 26229 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 25733 "parsing/parser.ml"
+# 26237 "parsing/parser.ml"
in
-# 3271 "parsing/parser.mly"
+# 3321 "parsing/parser.mly"
( _1 )
-# 25739 "parsing/parser.ml"
+# 26243 "parsing/parser.ml"
in
let _endpos_ty2_ = _endpos__1_inlined1_ in
let ty1 =
let _1 =
let _1 =
-# 3270 "parsing/parser.mly"
+# 3320 "parsing/parser.mly"
( Ptyp_package (package_type_of_module_type _1) )
-# 25748 "parsing/parser.ml"
+# 26252 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 25756 "parsing/parser.ml"
+# 26260 "parsing/parser.ml"
in
-# 3271 "parsing/parser.mly"
+# 3321 "parsing/parser.mly"
( _1 )
-# 25762 "parsing/parser.ml"
+# 26266 "parsing/parser.ml"
in
let _endpos = _endpos_ty2_ in
let _startpos = _startpos_e_ in
let _loc = (_startpos, _endpos) in
-# 1227 "parsing/parser.mly"
+# 1277 "parsing/parser.mly"
( ghexp ~loc:_loc (Pexp_coerce (e, Some ty1, ty2)) )
-# 25771 "parsing/parser.ml"
+# 26275 "parsing/parser.ml"
in
let attrs =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 25779 "parsing/parser.ml"
+# 26283 "parsing/parser.ml"
in
let _endpos = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1210 "parsing/parser.mly"
+# 1260 "parsing/parser.mly"
( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) )
-# 25788 "parsing/parser.ml"
+# 26292 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let ty2 =
let _1 =
let _1 =
-# 3270 "parsing/parser.mly"
+# 3320 "parsing/parser.mly"
( Ptyp_package (package_type_of_module_type _1) )
-# 25859 "parsing/parser.ml"
+# 26363 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 25867 "parsing/parser.ml"
+# 26371 "parsing/parser.ml"
in
-# 3271 "parsing/parser.mly"
+# 3321 "parsing/parser.mly"
( _1 )
-# 25873 "parsing/parser.ml"
+# 26377 "parsing/parser.ml"
in
let _endpos_ty2_ = _endpos__1_ in
let _startpos = _startpos_e_ in
let _loc = (_startpos, _endpos) in
-# 1229 "parsing/parser.mly"
+# 1279 "parsing/parser.mly"
( ghexp ~loc:_loc (Pexp_coerce (e, None, ty2)) )
-# 25883 "parsing/parser.ml"
+# 26387 "parsing/parser.ml"
in
let attrs =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 25891 "parsing/parser.ml"
+# 26395 "parsing/parser.ml"
in
let _endpos = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1210 "parsing/parser.mly"
+# 1260 "parsing/parser.mly"
( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) )
-# 25900 "parsing/parser.ml"
+# 26404 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.module_expr) = let _3 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 25962 "parsing/parser.ml"
+# 26466 "parsing/parser.ml"
in
let _loc__6_ = (_startpos__6_, _endpos__6_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1212 "parsing/parser.mly"
+# 1262 "parsing/parser.mly"
( unclosed "(" _loc__1_ ")" _loc__6_ )
-# 25970 "parsing/parser.ml"
+# 26474 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.module_expr) = let _3 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 26032 "parsing/parser.ml"
+# 26536 "parsing/parser.ml"
in
let _loc__6_ = (_startpos__6_, _endpos__6_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1214 "parsing/parser.mly"
+# 1264 "parsing/parser.mly"
( unclosed "(" _loc__1_ ")" _loc__6_ )
-# 26040 "parsing/parser.ml"
+# 26544 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.module_expr) = let _3 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 26095 "parsing/parser.ml"
+# 26599 "parsing/parser.ml"
in
let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1216 "parsing/parser.mly"
+# 1266 "parsing/parser.mly"
( unclosed "(" _loc__1_ ")" _loc__5_ )
-# 26103 "parsing/parser.ml"
+# 26607 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2;
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
+ } = _menhir_stack in
+ let _2 : unit = Obj.magic _2 in
+ let _1 : (Longident.t) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__2_ in
+ let _v : (
+# 801 "parsing/parser.mly"
+ (Longident.t)
+# 26639 "parsing/parser.ml"
+ ) =
+# 1170 "parsing/parser.mly"
+ ( _1 )
+# 26643 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2;
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
+ } = _menhir_stack in
+ let _2 : unit = Obj.magic _2 in
+ let _1 : (Longident.t) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__2_ in
+ let _v : (
+# 791 "parsing/parser.mly"
+ (Longident.t)
+# 26675 "parsing/parser.ml"
+ ) =
+# 1155 "parsing/parser.mly"
+ ( _1 )
+# 26679 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (
-# 776 "parsing/parser.mly"
+# 785 "parsing/parser.mly"
(Parsetree.core_type)
-# 26135 "parsing/parser.ml"
+# 26711 "parsing/parser.ml"
) =
-# 1109 "parsing/parser.mly"
+# 1130 "parsing/parser.mly"
( _1 )
-# 26139 "parsing/parser.ml"
+# 26715 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (
-# 778 "parsing/parser.mly"
+# 787 "parsing/parser.mly"
(Parsetree.expression)
-# 26171 "parsing/parser.ml"
+# 26747 "parsing/parser.ml"
+ ) =
+# 1135 "parsing/parser.mly"
+ ( _1 )
+# 26751 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2;
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
+ } = _menhir_stack in
+ let _2 : unit = Obj.magic _2 in
+ let _1 : (Longident.t) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__2_ in
+ let _v : (
+# 797 "parsing/parser.mly"
+ (Longident.t)
+# 26783 "parsing/parser.ml"
) =
-# 1114 "parsing/parser.mly"
+# 1160 "parsing/parser.mly"
( _1 )
-# 26175 "parsing/parser.ml"
+# 26787 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2;
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
+ } = _menhir_stack in
+ let _2 : unit = Obj.magic _2 in
+ let _1 : (Longident.t) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__2_ in
+ let _v : (
+# 799 "parsing/parser.mly"
+ (Longident.t)
+# 26819 "parsing/parser.ml"
+ ) =
+# 1165 "parsing/parser.mly"
+ ( _1 )
+# 26823 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2;
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
+ } = _menhir_stack in
+ let _2 : unit = Obj.magic _2 in
+ let _1 : (Longident.t) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__2_ in
+ let _v : (
+# 795 "parsing/parser.mly"
+ (Longident.t)
+# 26855 "parsing/parser.ml"
+ ) =
+# 1145 "parsing/parser.mly"
+ ( _1 )
+# 26859 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (
-# 780 "parsing/parser.mly"
+# 789 "parsing/parser.mly"
(Parsetree.pattern)
-# 26207 "parsing/parser.ml"
+# 26891 "parsing/parser.ml"
+ ) =
+# 1140 "parsing/parser.mly"
+ ( _1 )
+# 26895 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _;
+ MenhirLib.EngineTypes.semv = _2;
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
+ } = _menhir_stack in
+ let _2 : unit = Obj.magic _2 in
+ let _1 : (Longident.t) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__2_ in
+ let _v : (
+# 793 "parsing/parser.mly"
+ (Longident.t)
+# 26927 "parsing/parser.ml"
) =
-# 1119 "parsing/parser.mly"
+# 1150 "parsing/parser.mly"
( _1 )
-# 26211 "parsing/parser.ml"
+# 26931 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _loc__2_ = (_startpos__2_, _endpos__2_) in
let _sloc = (_symbolstartpos, _endpos) in
-# 2581 "parsing/parser.mly"
+# 2631 "parsing/parser.mly"
( mkpat_cons ~loc:_sloc _loc__2_ (ghpat ~loc:_sloc (Ppat_tuple[_1;_3])) )
-# 26255 "parsing/parser.ml"
+# 26975 "parsing/parser.ml"
in
-# 2569 "parsing/parser.mly"
+# 2619 "parsing/parser.mly"
( _1 )
-# 26261 "parsing/parser.ml"
+# 26981 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.pattern) = let _1 =
-# 2583 "parsing/parser.mly"
+# 2633 "parsing/parser.mly"
( Pat.attr _1 _2 )
-# 26293 "parsing/parser.ml"
+# 27013 "parsing/parser.ml"
in
-# 2569 "parsing/parser.mly"
+# 2619 "parsing/parser.mly"
( _1 )
-# 26298 "parsing/parser.ml"
+# 27018 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.pattern) = let _1 =
-# 2585 "parsing/parser.mly"
+# 2635 "parsing/parser.mly"
( _1 )
-# 26323 "parsing/parser.ml"
+# 27043 "parsing/parser.ml"
in
-# 2569 "parsing/parser.mly"
+# 2619 "parsing/parser.mly"
( _1 )
-# 26328 "parsing/parser.ml"
+# 27048 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
};
} = _menhir_stack in
- let _1_inlined1 : (string) = Obj.magic _1_inlined1 in
+ let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in
let _2 : unit = Obj.magic _2 in
let _1 : (Parsetree.pattern) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 26375 "parsing/parser.ml"
+# 27095 "parsing/parser.ml"
in
-# 2588 "parsing/parser.mly"
+# 2638 "parsing/parser.mly"
( Ppat_alias(_1, _3) )
-# 26381 "parsing/parser.ml"
+# 27101 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 26391 "parsing/parser.ml"
+# 27111 "parsing/parser.ml"
in
-# 2599 "parsing/parser.mly"
+# 2649 "parsing/parser.mly"
( _1 )
-# 26397 "parsing/parser.ml"
+# 27117 "parsing/parser.ml"
in
-# 2569 "parsing/parser.mly"
+# 2619 "parsing/parser.mly"
( _1 )
-# 26403 "parsing/parser.ml"
+# 27123 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2590 "parsing/parser.mly"
+# 2640 "parsing/parser.mly"
( expecting _loc__3_ "identifier" )
-# 26446 "parsing/parser.ml"
+# 27166 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 26456 "parsing/parser.ml"
+# 27176 "parsing/parser.ml"
in
-# 2599 "parsing/parser.mly"
+# 2649 "parsing/parser.mly"
( _1 )
-# 26462 "parsing/parser.ml"
+# 27182 "parsing/parser.ml"
in
-# 2569 "parsing/parser.mly"
+# 2619 "parsing/parser.mly"
( _1 )
-# 26468 "parsing/parser.ml"
+# 27188 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.pattern) = let _1 =
let _1 =
let _1 =
-# 2592 "parsing/parser.mly"
+# 2642 "parsing/parser.mly"
( Ppat_tuple(List.rev _1) )
-# 26495 "parsing/parser.ml"
+# 27215 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 26503 "parsing/parser.ml"
+# 27223 "parsing/parser.ml"
in
-# 2599 "parsing/parser.mly"
+# 2649 "parsing/parser.mly"
( _1 )
-# 26509 "parsing/parser.ml"
+# 27229 "parsing/parser.ml"
in
-# 2569 "parsing/parser.mly"
+# 2619 "parsing/parser.mly"
( _1 )
-# 26515 "parsing/parser.ml"
+# 27235 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2594 "parsing/parser.mly"
+# 2644 "parsing/parser.mly"
( expecting _loc__3_ "pattern" )
-# 26558 "parsing/parser.ml"
+# 27278 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 26568 "parsing/parser.ml"
+# 27288 "parsing/parser.ml"
in
-# 2599 "parsing/parser.mly"
+# 2649 "parsing/parser.mly"
( _1 )
-# 26574 "parsing/parser.ml"
+# 27294 "parsing/parser.ml"
in
-# 2569 "parsing/parser.mly"
+# 2619 "parsing/parser.mly"
( _1 )
-# 26580 "parsing/parser.ml"
+# 27300 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.pattern) = let _1 =
let _1 =
let _1 =
-# 2596 "parsing/parser.mly"
+# 2646 "parsing/parser.mly"
( Ppat_or(_1, _3) )
-# 26621 "parsing/parser.ml"
+# 27341 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 26630 "parsing/parser.ml"
+# 27350 "parsing/parser.ml"
in
-# 2599 "parsing/parser.mly"
+# 2649 "parsing/parser.mly"
( _1 )
-# 26636 "parsing/parser.ml"
+# 27356 "parsing/parser.ml"
in
-# 2569 "parsing/parser.mly"
+# 2619 "parsing/parser.mly"
( _1 )
-# 26642 "parsing/parser.ml"
+# 27362 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2598 "parsing/parser.mly"
+# 2648 "parsing/parser.mly"
( expecting _loc__3_ "pattern" )
-# 26685 "parsing/parser.ml"
+# 27405 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 26695 "parsing/parser.ml"
+# 27415 "parsing/parser.ml"
in
-# 2599 "parsing/parser.mly"
+# 2649 "parsing/parser.mly"
( _1 )
-# 26701 "parsing/parser.ml"
+# 27421 "parsing/parser.ml"
in
-# 2569 "parsing/parser.mly"
+# 2619 "parsing/parser.mly"
( _1 )
-# 26707 "parsing/parser.ml"
+# 27427 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 26757 "parsing/parser.ml"
+# 27477 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 26763 "parsing/parser.ml"
+# 27483 "parsing/parser.ml"
in
let _endpos = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2571 "parsing/parser.mly"
+# 2621 "parsing/parser.mly"
( mkpat_attrs ~loc:_sloc (Ppat_exception _3) _2)
-# 26772 "parsing/parser.ml"
+# 27492 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.pattern list) =
-# 2695 "parsing/parser.mly"
+# 2745 "parsing/parser.mly"
( _3 :: _1 )
-# 26811 "parsing/parser.ml"
+# 27531 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.pattern list) =
-# 2696 "parsing/parser.mly"
+# 2746 "parsing/parser.mly"
( [_3; _1] )
-# 26850 "parsing/parser.ml"
+# 27570 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__3_ in
let _v : (Parsetree.pattern list) = let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2697 "parsing/parser.mly"
+# 2747 "parsing/parser.mly"
( expecting _loc__3_ "pattern" )
-# 26890 "parsing/parser.ml"
+# 27610 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.pattern list) =
-# 2695 "parsing/parser.mly"
+# 2745 "parsing/parser.mly"
( _3 :: _1 )
-# 26929 "parsing/parser.ml"
+# 27649 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : (Parsetree.pattern list) =
-# 2696 "parsing/parser.mly"
+# 2746 "parsing/parser.mly"
( [_3; _1] )
-# 26968 "parsing/parser.ml"
+# 27688 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__3_ in
let _v : (Parsetree.pattern list) = let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2697 "parsing/parser.mly"
+# 2747 "parsing/parser.mly"
( expecting _loc__3_ "pattern" )
-# 27008 "parsing/parser.ml"
+# 27728 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.pattern) =
-# 2604 "parsing/parser.mly"
+# 2654 "parsing/parser.mly"
( _1 )
-# 27033 "parsing/parser.ml"
+# 27753 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 27071 "parsing/parser.ml"
+# 27791 "parsing/parser.ml"
in
-# 2607 "parsing/parser.mly"
+# 2657 "parsing/parser.mly"
( Ppat_construct(_1, Some _2) )
-# 27077 "parsing/parser.ml"
+# 27797 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 27087 "parsing/parser.ml"
+# 27807 "parsing/parser.ml"
in
-# 2610 "parsing/parser.mly"
+# 2660 "parsing/parser.mly"
( _1 )
-# 27093 "parsing/parser.ml"
+# 27813 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__2_ in
let _v : (Parsetree.pattern) = let _1 =
let _1 =
-# 2609 "parsing/parser.mly"
+# 2659 "parsing/parser.mly"
( Ppat_variant(_1, Some _2) )
-# 27126 "parsing/parser.ml"
+# 27846 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 27135 "parsing/parser.ml"
+# 27855 "parsing/parser.ml"
in
-# 2610 "parsing/parser.mly"
+# 2660 "parsing/parser.mly"
( _1 )
-# 27141 "parsing/parser.ml"
+# 27861 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 27191 "parsing/parser.ml"
+# 27911 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 27197 "parsing/parser.ml"
+# 27917 "parsing/parser.ml"
in
let _endpos = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2612 "parsing/parser.mly"
+# 2662 "parsing/parser.mly"
( mkpat_attrs ~loc:_sloc (Ppat_lazy _3) _2)
-# 27206 "parsing/parser.ml"
+# 27926 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _loc__2_ = (_startpos__2_, _endpos__2_) in
let _sloc = (_symbolstartpos, _endpos) in
-# 2581 "parsing/parser.mly"
+# 2631 "parsing/parser.mly"
( mkpat_cons ~loc:_sloc _loc__2_ (ghpat ~loc:_sloc (Ppat_tuple[_1;_3])) )
-# 27250 "parsing/parser.ml"
+# 27970 "parsing/parser.ml"
in
-# 2576 "parsing/parser.mly"
+# 2626 "parsing/parser.mly"
( _1 )
-# 27256 "parsing/parser.ml"
+# 27976 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.pattern) = let _1 =
-# 2583 "parsing/parser.mly"
+# 2633 "parsing/parser.mly"
( Pat.attr _1 _2 )
-# 27288 "parsing/parser.ml"
+# 28008 "parsing/parser.ml"
in
-# 2576 "parsing/parser.mly"
+# 2626 "parsing/parser.mly"
( _1 )
-# 27293 "parsing/parser.ml"
+# 28013 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.pattern) = let _1 =
-# 2585 "parsing/parser.mly"
+# 2635 "parsing/parser.mly"
( _1 )
-# 27318 "parsing/parser.ml"
+# 28038 "parsing/parser.ml"
in
-# 2576 "parsing/parser.mly"
+# 2626 "parsing/parser.mly"
( _1 )
-# 27323 "parsing/parser.ml"
+# 28043 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
};
} = _menhir_stack in
- let _1_inlined1 : (string) = Obj.magic _1_inlined1 in
+ let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in
let _2 : unit = Obj.magic _2 in
let _1 : (Parsetree.pattern) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 27370 "parsing/parser.ml"
+# 28090 "parsing/parser.ml"
in
-# 2588 "parsing/parser.mly"
+# 2638 "parsing/parser.mly"
( Ppat_alias(_1, _3) )
-# 27376 "parsing/parser.ml"
+# 28096 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 27386 "parsing/parser.ml"
+# 28106 "parsing/parser.ml"
in
-# 2599 "parsing/parser.mly"
+# 2649 "parsing/parser.mly"
( _1 )
-# 27392 "parsing/parser.ml"
+# 28112 "parsing/parser.ml"
in
-# 2576 "parsing/parser.mly"
+# 2626 "parsing/parser.mly"
( _1 )
-# 27398 "parsing/parser.ml"
+# 28118 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2590 "parsing/parser.mly"
+# 2640 "parsing/parser.mly"
( expecting _loc__3_ "identifier" )
-# 27441 "parsing/parser.ml"
+# 28161 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 27451 "parsing/parser.ml"
+# 28171 "parsing/parser.ml"
in
-# 2599 "parsing/parser.mly"
+# 2649 "parsing/parser.mly"
( _1 )
-# 27457 "parsing/parser.ml"
+# 28177 "parsing/parser.ml"
in
-# 2576 "parsing/parser.mly"
+# 2626 "parsing/parser.mly"
( _1 )
-# 27463 "parsing/parser.ml"
+# 28183 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.pattern) = let _1 =
let _1 =
let _1 =
-# 2592 "parsing/parser.mly"
+# 2642 "parsing/parser.mly"
( Ppat_tuple(List.rev _1) )
-# 27490 "parsing/parser.ml"
+# 28210 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 27498 "parsing/parser.ml"
+# 28218 "parsing/parser.ml"
in
-# 2599 "parsing/parser.mly"
+# 2649 "parsing/parser.mly"
( _1 )
-# 27504 "parsing/parser.ml"
+# 28224 "parsing/parser.ml"
in
-# 2576 "parsing/parser.mly"
+# 2626 "parsing/parser.mly"
( _1 )
-# 27510 "parsing/parser.ml"
+# 28230 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2594 "parsing/parser.mly"
+# 2644 "parsing/parser.mly"
( expecting _loc__3_ "pattern" )
-# 27553 "parsing/parser.ml"
+# 28273 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 27563 "parsing/parser.ml"
+# 28283 "parsing/parser.ml"
in
-# 2599 "parsing/parser.mly"
+# 2649 "parsing/parser.mly"
( _1 )
-# 27569 "parsing/parser.ml"
+# 28289 "parsing/parser.ml"
in
-# 2576 "parsing/parser.mly"
+# 2626 "parsing/parser.mly"
( _1 )
-# 27575 "parsing/parser.ml"
+# 28295 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.pattern) = let _1 =
let _1 =
let _1 =
-# 2596 "parsing/parser.mly"
+# 2646 "parsing/parser.mly"
( Ppat_or(_1, _3) )
-# 27616 "parsing/parser.ml"
+# 28336 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 27625 "parsing/parser.ml"
+# 28345 "parsing/parser.ml"
in
-# 2599 "parsing/parser.mly"
+# 2649 "parsing/parser.mly"
( _1 )
-# 27631 "parsing/parser.ml"
+# 28351 "parsing/parser.ml"
in
-# 2576 "parsing/parser.mly"
+# 2626 "parsing/parser.mly"
( _1 )
-# 27637 "parsing/parser.ml"
+# 28357 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2598 "parsing/parser.mly"
+# 2648 "parsing/parser.mly"
( expecting _loc__3_ "pattern" )
-# 27680 "parsing/parser.ml"
+# 28400 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 27690 "parsing/parser.ml"
+# 28410 "parsing/parser.ml"
in
-# 2599 "parsing/parser.mly"
+# 2649 "parsing/parser.mly"
( _1 )
-# 27696 "parsing/parser.ml"
+# 28416 "parsing/parser.ml"
in
-# 2576 "parsing/parser.mly"
+# 2626 "parsing/parser.mly"
( _1 )
-# 27702 "parsing/parser.ml"
+# 28422 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 27723 "parsing/parser.ml"
+# 28443 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 27737 "parsing/parser.ml"
+# 28457 "parsing/parser.ml"
in
-# 2054 "parsing/parser.mly"
+# 2104 "parsing/parser.mly"
( Ppat_var _1 )
-# 27743 "parsing/parser.ml"
+# 28463 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 27752 "parsing/parser.ml"
+# 28472 "parsing/parser.ml"
in
-# 2056 "parsing/parser.mly"
+# 2106 "parsing/parser.mly"
( _1 )
-# 27758 "parsing/parser.ml"
+# 28478 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.pattern) = let _1 =
let _1 =
-# 2055 "parsing/parser.mly"
+# 2105 "parsing/parser.mly"
( Ppat_any )
-# 27784 "parsing/parser.ml"
+# 28504 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 27792 "parsing/parser.ml"
+# 28512 "parsing/parser.ml"
in
-# 2056 "parsing/parser.mly"
+# 2106 "parsing/parser.mly"
( _1 )
-# 27798 "parsing/parser.ml"
+# 28518 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.payload) =
-# 3689 "parsing/parser.mly"
+# 3755 "parsing/parser.mly"
( PStr _1 )
-# 27823 "parsing/parser.ml"
+# 28543 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.payload) =
-# 3690 "parsing/parser.mly"
+# 3756 "parsing/parser.mly"
( PSig _2 )
-# 27855 "parsing/parser.ml"
+# 28575 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.payload) =
-# 3691 "parsing/parser.mly"
+# 3757 "parsing/parser.mly"
( PTyp _2 )
-# 27887 "parsing/parser.ml"
+# 28607 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.payload) =
-# 3692 "parsing/parser.mly"
+# 3758 "parsing/parser.mly"
( PPat (_2, None) )
-# 27919 "parsing/parser.ml"
+# 28639 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : (Parsetree.payload) =
-# 3693 "parsing/parser.mly"
+# 3759 "parsing/parser.mly"
( PPat (_2, Some _4) )
-# 27965 "parsing/parser.ml"
+# 28685 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.core_type) =
-# 3108 "parsing/parser.mly"
+# 3158 "parsing/parser.mly"
( _1 )
-# 27990 "parsing/parser.ml"
+# 28710 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 28033 "parsing/parser.ml"
+# 28753 "parsing/parser.ml"
in
-# 894 "parsing/parser.mly"
+# 915 "parsing/parser.mly"
( xs )
-# 28038 "parsing/parser.ml"
+# 28758 "parsing/parser.ml"
in
-# 3100 "parsing/parser.mly"
+# 3150 "parsing/parser.mly"
( _1 )
-# 28044 "parsing/parser.ml"
+# 28764 "parsing/parser.ml"
in
-# 3104 "parsing/parser.mly"
+# 3154 "parsing/parser.mly"
( Ptyp_poly(_1, _3) )
-# 28050 "parsing/parser.ml"
+# 28770 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos__3_, _startpos_xs_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 28060 "parsing/parser.ml"
+# 28780 "parsing/parser.ml"
in
-# 3110 "parsing/parser.mly"
+# 3160 "parsing/parser.mly"
( _1 )
-# 28066 "parsing/parser.ml"
+# 28786 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.core_type) = let _1 =
-# 3139 "parsing/parser.mly"
+# 3189 "parsing/parser.mly"
( _1 )
-# 28091 "parsing/parser.ml"
+# 28811 "parsing/parser.ml"
in
-# 3108 "parsing/parser.mly"
+# 3158 "parsing/parser.mly"
( _1 )
-# 28096 "parsing/parser.ml"
+# 28816 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.core_type) = let _1 =
let _1 =
let _3 =
-# 3139 "parsing/parser.mly"
+# 3189 "parsing/parser.mly"
( _1 )
-# 28137 "parsing/parser.ml"
+# 28857 "parsing/parser.ml"
in
let _1 =
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 28144 "parsing/parser.ml"
+# 28864 "parsing/parser.ml"
in
-# 894 "parsing/parser.mly"
+# 915 "parsing/parser.mly"
( xs )
-# 28149 "parsing/parser.ml"
+# 28869 "parsing/parser.ml"
in
-# 3100 "parsing/parser.mly"
+# 3150 "parsing/parser.mly"
( _1 )
-# 28155 "parsing/parser.ml"
+# 28875 "parsing/parser.ml"
in
-# 3104 "parsing/parser.mly"
+# 3154 "parsing/parser.mly"
( Ptyp_poly(_1, _3) )
-# 28161 "parsing/parser.ml"
+# 28881 "parsing/parser.ml"
in
let _startpos__1_ = _startpos_xs_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 28171 "parsing/parser.ml"
+# 28891 "parsing/parser.ml"
in
-# 3110 "parsing/parser.mly"
+# 3160 "parsing/parser.mly"
( _1 )
-# 28177 "parsing/parser.ml"
+# 28897 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3656 "parsing/parser.mly"
+# 3718 "parsing/parser.mly"
( Attr.mk ~loc:(make_loc _sloc) _2 _3 )
-# 28226 "parsing/parser.ml"
+# 28946 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _7 : unit = Obj.magic _7 in
let ty : (Parsetree.core_type) = Obj.magic ty in
let _5 : unit = Obj.magic _5 in
- let _1_inlined2 : (string) = Obj.magic _1_inlined2 in
+ let _1_inlined2 : (Asttypes.label) = Obj.magic _1_inlined2 in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
let ext : (string Asttypes.loc option) = Obj.magic ext in
let _1 : unit = Obj.magic _1 in
let _v : (Parsetree.value_description * string Asttypes.loc option) = let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 28309 "parsing/parser.ml"
+# 29029 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 28321 "parsing/parser.ml"
+# 29041 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 28329 "parsing/parser.ml"
+# 29049 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2756 "parsing/parser.mly"
+# 2806 "parsing/parser.mly"
( let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
let docs = symbol_docs _sloc in
Val.mk id ty ~prim ~attrs ~loc ~docs,
ext )
-# 28342 "parsing/parser.ml"
+# 29062 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Asttypes.private_flag) = let _1 =
-# 3524 "parsing/parser.mly"
+# 3586 "parsing/parser.mly"
( Public )
-# 28360 "parsing/parser.ml"
+# 29080 "parsing/parser.ml"
in
-# 3521 "parsing/parser.mly"
+# 3583 "parsing/parser.mly"
( _1 )
-# 28365 "parsing/parser.ml"
+# 29085 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.private_flag) = let _1 =
-# 3525 "parsing/parser.mly"
+# 3587 "parsing/parser.mly"
( Private )
-# 28390 "parsing/parser.ml"
+# 29110 "parsing/parser.ml"
in
-# 3521 "parsing/parser.mly"
+# 3583 "parsing/parser.mly"
( _1 )
-# 28395 "parsing/parser.ml"
+# 29115 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Asttypes.private_flag * Asttypes.virtual_flag) =
-# 3547 "parsing/parser.mly"
+# 3609 "parsing/parser.mly"
( Public, Concrete )
-# 28413 "parsing/parser.ml"
+# 29133 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.private_flag * Asttypes.virtual_flag) =
-# 3548 "parsing/parser.mly"
+# 3610 "parsing/parser.mly"
( Private, Concrete )
-# 28438 "parsing/parser.ml"
+# 29158 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.private_flag * Asttypes.virtual_flag) =
-# 3549 "parsing/parser.mly"
+# 3611 "parsing/parser.mly"
( Public, Virtual )
-# 28463 "parsing/parser.ml"
+# 29183 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Asttypes.private_flag * Asttypes.virtual_flag) =
-# 3550 "parsing/parser.mly"
+# 3612 "parsing/parser.mly"
( Private, Virtual )
-# 28495 "parsing/parser.ml"
+# 29215 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Asttypes.private_flag * Asttypes.virtual_flag) =
-# 3551 "parsing/parser.mly"
+# 3613 "parsing/parser.mly"
( Private, Virtual )
-# 28527 "parsing/parser.ml"
+# 29247 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Asttypes.rec_flag) =
-# 3504 "parsing/parser.mly"
+# 3566 "parsing/parser.mly"
( Nonrecursive )
-# 28545 "parsing/parser.ml"
+# 29265 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.rec_flag) =
-# 3505 "parsing/parser.mly"
+# 3567 "parsing/parser.mly"
( Recursive )
-# 28570 "parsing/parser.ml"
+# 29290 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos_fields_ in
let _v : (Parsetree.expression option *
(Longident.t Asttypes.loc * Parsetree.expression) list) = let eo =
-# 124 "menhir/standard.mly"
+# 124 "<standard.mly>"
( None )
-# 28596 "parsing/parser.ml"
+# 29316 "parsing/parser.ml"
in
-# 2501 "parsing/parser.mly"
+# 2551 "parsing/parser.mly"
( eo, fields )
-# 28601 "parsing/parser.ml"
+# 29321 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression option *
(Longident.t Asttypes.loc * Parsetree.expression) list) = let eo =
let x =
-# 191 "menhir/standard.mly"
+# 191 "<standard.mly>"
( x )
-# 28642 "parsing/parser.ml"
+# 29362 "parsing/parser.ml"
in
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 28647 "parsing/parser.ml"
+# 29367 "parsing/parser.ml"
in
-# 2501 "parsing/parser.mly"
+# 2551 "parsing/parser.mly"
( eo, fields )
-# 28653 "parsing/parser.ml"
+# 29373 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_d_ in
let _endpos = _endpos_d_ in
let _v : (Parsetree.constructor_declaration list) = let x =
-# 2930 "parsing/parser.mly"
+# 2980 "parsing/parser.mly"
(
let cid, args, res, attrs, loc, info = d in
Type.constructor cid ~args ?res ~attrs ~loc ~info
)
-# 28683 "parsing/parser.ml"
+# 29403 "parsing/parser.ml"
in
-# 1004 "parsing/parser.mly"
+# 1025 "parsing/parser.mly"
( [x] )
-# 28688 "parsing/parser.ml"
+# 29408 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_d_ in
let _endpos = _endpos_d_ in
let _v : (Parsetree.constructor_declaration list) = let x =
-# 2930 "parsing/parser.mly"
+# 2980 "parsing/parser.mly"
(
let cid, args, res, attrs, loc, info = d in
Type.constructor cid ~args ?res ~attrs ~loc ~info
)
-# 28718 "parsing/parser.ml"
+# 29438 "parsing/parser.ml"
in
-# 1007 "parsing/parser.mly"
+# 1028 "parsing/parser.mly"
( [x] )
-# 28723 "parsing/parser.ml"
+# 29443 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xs_ in
let _endpos = _endpos_d_ in
let _v : (Parsetree.constructor_declaration list) = let x =
-# 2930 "parsing/parser.mly"
+# 2980 "parsing/parser.mly"
(
let cid, args, res, attrs, loc, info = d in
Type.constructor cid ~args ?res ~attrs ~loc ~info
)
-# 28760 "parsing/parser.ml"
+# 29480 "parsing/parser.ml"
in
-# 1011 "parsing/parser.mly"
+# 1032 "parsing/parser.mly"
( x :: xs )
-# 28765 "parsing/parser.ml"
+# 29485 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos_d_ in
let _v : (Parsetree.extension_constructor list) = let x =
let _1 =
-# 3042 "parsing/parser.mly"
+# 3092 "parsing/parser.mly"
(
let cid, args, res, attrs, loc, info = d in
Te.decl cid ~args ?res ~attrs ~loc ~info
)
-# 28796 "parsing/parser.ml"
+# 29516 "parsing/parser.ml"
in
-# 3036 "parsing/parser.mly"
+# 3086 "parsing/parser.mly"
( _1 )
-# 28801 "parsing/parser.ml"
+# 29521 "parsing/parser.ml"
in
-# 1004 "parsing/parser.mly"
+# 1025 "parsing/parser.mly"
( [x] )
-# 28807 "parsing/parser.ml"
+# 29527 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.extension_constructor list) = let x =
-# 3038 "parsing/parser.mly"
+# 3088 "parsing/parser.mly"
( _1 )
-# 28832 "parsing/parser.ml"
+# 29552 "parsing/parser.ml"
in
-# 1004 "parsing/parser.mly"
+# 1025 "parsing/parser.mly"
( [x] )
-# 28837 "parsing/parser.ml"
+# 29557 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos_d_ in
let _v : (Parsetree.extension_constructor list) = let x =
let _1 =
-# 3042 "parsing/parser.mly"
+# 3092 "parsing/parser.mly"
(
let cid, args, res, attrs, loc, info = d in
Te.decl cid ~args ?res ~attrs ~loc ~info
)
-# 28868 "parsing/parser.ml"
+# 29588 "parsing/parser.ml"
in
-# 3036 "parsing/parser.mly"
+# 3086 "parsing/parser.mly"
( _1 )
-# 28873 "parsing/parser.ml"
+# 29593 "parsing/parser.ml"
in
-# 1007 "parsing/parser.mly"
+# 1028 "parsing/parser.mly"
( [x] )
-# 28879 "parsing/parser.ml"
+# 29599 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.extension_constructor list) = let x =
-# 3038 "parsing/parser.mly"
+# 3088 "parsing/parser.mly"
( _1 )
-# 28904 "parsing/parser.ml"
+# 29624 "parsing/parser.ml"
in
-# 1007 "parsing/parser.mly"
+# 1028 "parsing/parser.mly"
( [x] )
-# 28909 "parsing/parser.ml"
+# 29629 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos_d_ in
let _v : (Parsetree.extension_constructor list) = let x =
let _1 =
-# 3042 "parsing/parser.mly"
+# 3092 "parsing/parser.mly"
(
let cid, args, res, attrs, loc, info = d in
Te.decl cid ~args ?res ~attrs ~loc ~info
)
-# 28947 "parsing/parser.ml"
+# 29667 "parsing/parser.ml"
in
-# 3036 "parsing/parser.mly"
+# 3086 "parsing/parser.mly"
( _1 )
-# 28952 "parsing/parser.ml"
+# 29672 "parsing/parser.ml"
in
-# 1011 "parsing/parser.mly"
+# 1032 "parsing/parser.mly"
( x :: xs )
-# 28958 "parsing/parser.ml"
+# 29678 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xs_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.extension_constructor list) = let x =
-# 3038 "parsing/parser.mly"
+# 3088 "parsing/parser.mly"
( _1 )
-# 28990 "parsing/parser.ml"
+# 29710 "parsing/parser.ml"
in
-# 1011 "parsing/parser.mly"
+# 1032 "parsing/parser.mly"
( x :: xs )
-# 28995 "parsing/parser.ml"
+# 29715 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_d_ in
let _endpos = _endpos_d_ in
let _v : (Parsetree.extension_constructor list) = let x =
-# 3042 "parsing/parser.mly"
+# 3092 "parsing/parser.mly"
(
let cid, args, res, attrs, loc, info = d in
Te.decl cid ~args ?res ~attrs ~loc ~info
)
-# 29025 "parsing/parser.ml"
+# 29745 "parsing/parser.ml"
in
-# 1004 "parsing/parser.mly"
+# 1025 "parsing/parser.mly"
( [x] )
-# 29030 "parsing/parser.ml"
+# 29750 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_d_ in
let _endpos = _endpos_d_ in
let _v : (Parsetree.extension_constructor list) = let x =
-# 3042 "parsing/parser.mly"
+# 3092 "parsing/parser.mly"
(
let cid, args, res, attrs, loc, info = d in
Te.decl cid ~args ?res ~attrs ~loc ~info
)
-# 29060 "parsing/parser.ml"
+# 29780 "parsing/parser.ml"
in
-# 1007 "parsing/parser.mly"
+# 1028 "parsing/parser.mly"
( [x] )
-# 29065 "parsing/parser.ml"
+# 29785 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xs_ in
let _endpos = _endpos_d_ in
let _v : (Parsetree.extension_constructor list) = let x =
-# 3042 "parsing/parser.mly"
+# 3092 "parsing/parser.mly"
(
let cid, args, res, attrs, loc, info = d in
Te.decl cid ~args ?res ~attrs ~loc ~info
)
-# 29102 "parsing/parser.ml"
+# 29822 "parsing/parser.ml"
in
-# 1011 "parsing/parser.mly"
+# 1032 "parsing/parser.mly"
( x :: xs )
-# 29107 "parsing/parser.ml"
+# 29827 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) list) =
-# 870 "parsing/parser.mly"
+# 891 "parsing/parser.mly"
( [] )
-# 29125 "parsing/parser.ml"
+# 29845 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1934 "parsing/parser.mly"
+# 1984 "parsing/parser.mly"
( _1, _3, make_loc _sloc )
-# 29184 "parsing/parser.ml"
+# 29904 "parsing/parser.ml"
in
-# 183 "menhir/standard.mly"
+# 183 "<standard.mly>"
( x )
-# 29190 "parsing/parser.ml"
+# 29910 "parsing/parser.ml"
in
-# 872 "parsing/parser.mly"
+# 893 "parsing/parser.mly"
( x :: xs )
-# 29196 "parsing/parser.ml"
+# 29916 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.functor_parameter list) =
-# 884 "parsing/parser.mly"
+# 905 "parsing/parser.mly"
( [ x ] )
-# 29221 "parsing/parser.ml"
+# 29941 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xs_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.functor_parameter list) =
-# 886 "parsing/parser.mly"
+# 907 "parsing/parser.mly"
( x :: xs )
-# 29253 "parsing/parser.ml"
+# 29973 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : ((Asttypes.arg_label * Parsetree.expression) list) =
-# 884 "parsing/parser.mly"
+# 905 "parsing/parser.mly"
( [ x ] )
-# 29278 "parsing/parser.ml"
+# 29998 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xs_ in
let _endpos = _endpos_x_ in
let _v : ((Asttypes.arg_label * Parsetree.expression) list) =
-# 886 "parsing/parser.mly"
+# 907 "parsing/parser.mly"
( x :: xs )
-# 29310 "parsing/parser.ml"
+# 30030 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : (Asttypes.label list) =
-# 884 "parsing/parser.mly"
+# 905 "parsing/parser.mly"
( [ x ] )
-# 29335 "parsing/parser.ml"
+# 30055 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xs_ in
let _endpos = _endpos_x_ in
let _v : (Asttypes.label list) =
-# 886 "parsing/parser.mly"
+# 907 "parsing/parser.mly"
( x :: xs )
-# 29367 "parsing/parser.ml"
+# 30087 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 29405 "parsing/parser.ml"
+# 30125 "parsing/parser.ml"
in
-# 3096 "parsing/parser.mly"
+# 3146 "parsing/parser.mly"
( _2 )
-# 29411 "parsing/parser.ml"
+# 30131 "parsing/parser.ml"
in
-# 884 "parsing/parser.mly"
+# 905 "parsing/parser.mly"
( [ x ] )
-# 29417 "parsing/parser.ml"
+# 30137 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 29462 "parsing/parser.ml"
+# 30182 "parsing/parser.ml"
in
-# 3096 "parsing/parser.mly"
+# 3146 "parsing/parser.mly"
( _2 )
-# 29468 "parsing/parser.ml"
+# 30188 "parsing/parser.ml"
in
-# 886 "parsing/parser.mly"
+# 907 "parsing/parser.mly"
( x :: xs )
-# 29474 "parsing/parser.ml"
+# 30194 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.case list) = let _1 =
-# 124 "menhir/standard.mly"
+# 124 "<standard.mly>"
( None )
-# 29499 "parsing/parser.ml"
+# 30219 "parsing/parser.ml"
in
-# 975 "parsing/parser.mly"
+# 996 "parsing/parser.mly"
( [x] )
-# 29504 "parsing/parser.ml"
+# 30224 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.case list) = let _1 =
let x = x_inlined1 in
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 29538 "parsing/parser.ml"
+# 30258 "parsing/parser.ml"
in
-# 975 "parsing/parser.mly"
+# 996 "parsing/parser.mly"
( [x] )
-# 29544 "parsing/parser.ml"
+# 30264 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xs_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.case list) =
-# 979 "parsing/parser.mly"
+# 1000 "parsing/parser.mly"
( x :: xs )
-# 29583 "parsing/parser.ml"
+# 30303 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.core_type list) = let xs =
let x =
-# 3139 "parsing/parser.mly"
+# 3189 "parsing/parser.mly"
( _1 )
-# 29609 "parsing/parser.ml"
+# 30329 "parsing/parser.ml"
in
-# 910 "parsing/parser.mly"
+# 931 "parsing/parser.mly"
( [ x ] )
-# 29614 "parsing/parser.ml"
+# 30334 "parsing/parser.ml"
in
-# 918 "parsing/parser.mly"
+# 939 "parsing/parser.mly"
( xs )
-# 29620 "parsing/parser.ml"
+# 30340 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.core_type list) = let xs =
let x =
-# 3139 "parsing/parser.mly"
+# 3189 "parsing/parser.mly"
( _1 )
-# 29660 "parsing/parser.ml"
+# 30380 "parsing/parser.ml"
in
-# 914 "parsing/parser.mly"
+# 935 "parsing/parser.mly"
( x :: xs )
-# 29665 "parsing/parser.ml"
+# 30385 "parsing/parser.ml"
in
-# 918 "parsing/parser.mly"
+# 939 "parsing/parser.mly"
( xs )
-# 29671 "parsing/parser.ml"
+# 30391 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.with_constraint list) = let xs =
-# 910 "parsing/parser.mly"
+# 931 "parsing/parser.mly"
( [ x ] )
-# 29696 "parsing/parser.ml"
+# 30416 "parsing/parser.ml"
in
-# 918 "parsing/parser.mly"
+# 939 "parsing/parser.mly"
( xs )
-# 29701 "parsing/parser.ml"
+# 30421 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xs_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.with_constraint list) = let xs =
-# 914 "parsing/parser.mly"
+# 935 "parsing/parser.mly"
( x :: xs )
-# 29740 "parsing/parser.ml"
+# 30460 "parsing/parser.ml"
in
-# 918 "parsing/parser.mly"
+# 939 "parsing/parser.mly"
( xs )
-# 29745 "parsing/parser.ml"
+# 30465 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.row_field list) = let xs =
-# 910 "parsing/parser.mly"
+# 931 "parsing/parser.mly"
( [ x ] )
-# 29770 "parsing/parser.ml"
+# 30490 "parsing/parser.ml"
in
-# 918 "parsing/parser.mly"
+# 939 "parsing/parser.mly"
( xs )
-# 29775 "parsing/parser.ml"
+# 30495 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xs_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.row_field list) = let xs =
-# 914 "parsing/parser.mly"
+# 935 "parsing/parser.mly"
( x :: xs )
-# 29814 "parsing/parser.ml"
+# 30534 "parsing/parser.ml"
in
-# 918 "parsing/parser.mly"
+# 939 "parsing/parser.mly"
( xs )
-# 29819 "parsing/parser.ml"
+# 30539 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.core_type list) = let xs =
-# 910 "parsing/parser.mly"
+# 931 "parsing/parser.mly"
( [ x ] )
-# 29844 "parsing/parser.ml"
+# 30564 "parsing/parser.ml"
in
-# 918 "parsing/parser.mly"
+# 939 "parsing/parser.mly"
( xs )
-# 29849 "parsing/parser.ml"
+# 30569 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xs_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.core_type list) = let xs =
-# 914 "parsing/parser.mly"
+# 935 "parsing/parser.mly"
( x :: xs )
-# 29888 "parsing/parser.ml"
+# 30608 "parsing/parser.ml"
in
-# 918 "parsing/parser.mly"
+# 939 "parsing/parser.mly"
( xs )
-# 29893 "parsing/parser.ml"
+# 30613 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : ((Parsetree.core_type * Asttypes.variance) list) = let xs =
-# 910 "parsing/parser.mly"
+# 931 "parsing/parser.mly"
( [ x ] )
-# 29918 "parsing/parser.ml"
+# 30638 "parsing/parser.ml"
in
-# 918 "parsing/parser.mly"
+# 939 "parsing/parser.mly"
( xs )
-# 29923 "parsing/parser.ml"
+# 30643 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xs_ in
let _endpos = _endpos_x_ in
let _v : ((Parsetree.core_type * Asttypes.variance) list) = let xs =
-# 914 "parsing/parser.mly"
+# 935 "parsing/parser.mly"
( x :: xs )
-# 29962 "parsing/parser.ml"
+# 30682 "parsing/parser.ml"
in
-# 918 "parsing/parser.mly"
+# 939 "parsing/parser.mly"
( xs )
-# 29967 "parsing/parser.ml"
+# 30687 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.core_type list) = let xs =
-# 910 "parsing/parser.mly"
+# 931 "parsing/parser.mly"
( [ x ] )
-# 29992 "parsing/parser.ml"
+# 30712 "parsing/parser.ml"
in
-# 918 "parsing/parser.mly"
+# 939 "parsing/parser.mly"
( xs )
-# 29997 "parsing/parser.ml"
+# 30717 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xs_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.core_type list) = let xs =
-# 914 "parsing/parser.mly"
+# 935 "parsing/parser.mly"
( x :: xs )
-# 30036 "parsing/parser.ml"
+# 30756 "parsing/parser.ml"
in
-# 918 "parsing/parser.mly"
+# 939 "parsing/parser.mly"
( xs )
-# 30041 "parsing/parser.ml"
+# 30761 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xs_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.core_type list) =
-# 941 "parsing/parser.mly"
+# 962 "parsing/parser.mly"
( x :: xs )
-# 30080 "parsing/parser.ml"
+# 30800 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x1_ in
let _endpos = _endpos_x2_ in
let _v : (Parsetree.core_type list) =
-# 945 "parsing/parser.mly"
+# 966 "parsing/parser.mly"
( [ x2; x1 ] )
-# 30119 "parsing/parser.ml"
+# 30839 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xs_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.expression list) =
-# 941 "parsing/parser.mly"
+# 962 "parsing/parser.mly"
( x :: xs )
-# 30158 "parsing/parser.ml"
+# 30878 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x1_ in
let _endpos = _endpos_x2_ in
let _v : (Parsetree.expression list) =
-# 945 "parsing/parser.mly"
+# 966 "parsing/parser.mly"
( [ x2; x1 ] )
-# 30197 "parsing/parser.ml"
+# 30917 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xs_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.core_type list) =
-# 941 "parsing/parser.mly"
+# 962 "parsing/parser.mly"
( x :: xs )
-# 30236 "parsing/parser.ml"
+# 30956 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x1_ in
let _endpos = _endpos_x2_ in
let _v : (Parsetree.core_type list) =
-# 945 "parsing/parser.mly"
+# 966 "parsing/parser.mly"
( [ x2; x1 ] )
-# 30275 "parsing/parser.ml"
+# 30995 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.row_field) =
-# 3279 "parsing/parser.mly"
+# 3329 "parsing/parser.mly"
( _1 )
-# 30300 "parsing/parser.ml"
+# 31020 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3281 "parsing/parser.mly"
+# 3331 "parsing/parser.mly"
( Rf.inherit_ ~loc:(make_loc _sloc) _1 )
-# 30328 "parsing/parser.ml"
+# 31048 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.expression list) = let _2 =
-# 124 "menhir/standard.mly"
+# 124 "<standard.mly>"
( None )
-# 30353 "parsing/parser.ml"
+# 31073 "parsing/parser.ml"
in
-# 962 "parsing/parser.mly"
+# 983 "parsing/parser.mly"
( [x] )
-# 30358 "parsing/parser.ml"
+# 31078 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression list) = let _2 =
let x = x_inlined1 in
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 30392 "parsing/parser.ml"
+# 31112 "parsing/parser.ml"
in
-# 962 "parsing/parser.mly"
+# 983 "parsing/parser.mly"
( [x] )
-# 30398 "parsing/parser.ml"
+# 31118 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_xs_ in
let _v : (Parsetree.expression list) =
-# 966 "parsing/parser.mly"
+# 987 "parsing/parser.mly"
( x :: xs )
-# 30437 "parsing/parser.ml"
+# 31157 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let oe : (Parsetree.expression option) = Obj.magic oe in
let _1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 30465 "parsing/parser.ml"
+# 31185 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos_oe_ in
let _v : ((Asttypes.label Asttypes.loc * Parsetree.expression) list) = let _2 =
-# 124 "menhir/standard.mly"
+# 124 "<standard.mly>"
( None )
-# 30473 "parsing/parser.ml"
+# 31193 "parsing/parser.ml"
in
let x =
let label =
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 30480 "parsing/parser.ml"
+# 31200 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 30488 "parsing/parser.ml"
+# 31208 "parsing/parser.ml"
in
let _startpos_label_ = _startpos__1_ in
let _symbolstartpos = _startpos_label_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2524 "parsing/parser.mly"
+# 2574 "parsing/parser.mly"
( let e =
match oe with
| None ->
e
in
label, e )
-# 30506 "parsing/parser.ml"
+# 31226 "parsing/parser.ml"
in
-# 962 "parsing/parser.mly"
+# 983 "parsing/parser.mly"
( [x] )
-# 30512 "parsing/parser.ml"
+# 31232 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let x : unit = Obj.magic x in
let oe : (Parsetree.expression option) = Obj.magic oe in
let _1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 30547 "parsing/parser.ml"
+# 31267 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos_x_ in
let _v : ((Asttypes.label Asttypes.loc * Parsetree.expression) list) = let _2 =
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 30555 "parsing/parser.ml"
+# 31275 "parsing/parser.ml"
in
let x =
let label =
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 30562 "parsing/parser.ml"
+# 31282 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 30570 "parsing/parser.ml"
+# 31290 "parsing/parser.ml"
in
let _startpos_label_ = _startpos__1_ in
let _symbolstartpos = _startpos_label_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2524 "parsing/parser.mly"
+# 2574 "parsing/parser.mly"
( let e =
match oe with
| None ->
e
in
label, e )
-# 30588 "parsing/parser.ml"
+# 31308 "parsing/parser.ml"
in
-# 962 "parsing/parser.mly"
+# 983 "parsing/parser.mly"
( [x] )
-# 30594 "parsing/parser.ml"
+# 31314 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 : unit = Obj.magic _2 in
let oe : (Parsetree.expression option) = Obj.magic oe in
let _1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 30636 "parsing/parser.ml"
+# 31356 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _v : ((Asttypes.label Asttypes.loc * Parsetree.expression) list) = let x =
let label =
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 30646 "parsing/parser.ml"
+# 31366 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 30654 "parsing/parser.ml"
+# 31374 "parsing/parser.ml"
in
let _startpos_label_ = _startpos__1_ in
let _symbolstartpos = _startpos_label_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2524 "parsing/parser.mly"
+# 2574 "parsing/parser.mly"
( let e =
match oe with
| None ->
e
in
label, e )
-# 30672 "parsing/parser.ml"
+# 31392 "parsing/parser.ml"
in
-# 966 "parsing/parser.mly"
+# 987 "parsing/parser.mly"
( x :: xs )
-# 30678 "parsing/parser.ml"
+# 31398 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : (Parsetree.pattern list) = let _2 =
-# 124 "menhir/standard.mly"
+# 124 "<standard.mly>"
( None )
-# 30703 "parsing/parser.ml"
+# 31423 "parsing/parser.ml"
in
-# 962 "parsing/parser.mly"
+# 983 "parsing/parser.mly"
( [x] )
-# 30708 "parsing/parser.ml"
+# 31428 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.pattern list) = let _2 =
let x = x_inlined1 in
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 30742 "parsing/parser.ml"
+# 31462 "parsing/parser.ml"
in
-# 962 "parsing/parser.mly"
+# 983 "parsing/parser.mly"
( [x] )
-# 30748 "parsing/parser.ml"
+# 31468 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x_ in
let _endpos = _endpos_xs_ in
let _v : (Parsetree.pattern list) =
-# 966 "parsing/parser.mly"
+# 987 "parsing/parser.mly"
( x :: xs )
-# 30787 "parsing/parser.ml"
+# 31507 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_eo_ in
let _v : ((Longident.t Asttypes.loc * Parsetree.expression) list) = let _2 =
-# 124 "menhir/standard.mly"
+# 124 "<standard.mly>"
( None )
-# 30826 "parsing/parser.ml"
+# 31546 "parsing/parser.ml"
in
let x =
let label =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 30836 "parsing/parser.ml"
+# 31556 "parsing/parser.ml"
in
let _startpos_label_ = _startpos__1_ in
let _symbolstartpos = _startpos_label_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2507 "parsing/parser.mly"
+# 2557 "parsing/parser.mly"
( let e =
match eo with
| None ->
e
in
label, mkexp_opt_constraint ~loc:_sloc e c )
-# 30854 "parsing/parser.ml"
+# 31574 "parsing/parser.ml"
in
-# 962 "parsing/parser.mly"
+# 983 "parsing/parser.mly"
( [x] )
-# 30860 "parsing/parser.ml"
+# 31580 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_x_ in
let _v : ((Longident.t Asttypes.loc * Parsetree.expression) list) = let _2 =
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 30906 "parsing/parser.ml"
+# 31626 "parsing/parser.ml"
in
let x =
let label =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 30916 "parsing/parser.ml"
+# 31636 "parsing/parser.ml"
in
let _startpos_label_ = _startpos__1_ in
let _symbolstartpos = _startpos_label_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2507 "parsing/parser.mly"
+# 2557 "parsing/parser.mly"
( let e =
match eo with
| None ->
e
in
label, mkexp_opt_constraint ~loc:_sloc e c )
-# 30934 "parsing/parser.ml"
+# 31654 "parsing/parser.ml"
in
-# 962 "parsing/parser.mly"
+# 983 "parsing/parser.mly"
( [x] )
-# 30940 "parsing/parser.ml"
+# 31660 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 30998 "parsing/parser.ml"
+# 31718 "parsing/parser.ml"
in
let _startpos_label_ = _startpos__1_ in
let _symbolstartpos = _startpos_label_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2507 "parsing/parser.mly"
+# 2557 "parsing/parser.mly"
( let e =
match eo with
| None ->
e
in
label, mkexp_opt_constraint ~loc:_sloc e c )
-# 31016 "parsing/parser.ml"
+# 31736 "parsing/parser.ml"
in
-# 966 "parsing/parser.mly"
+# 987 "parsing/parser.mly"
( x :: xs )
-# 31022 "parsing/parser.ml"
+# 31742 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.expression) =
-# 2023 "parsing/parser.mly"
+# 2073 "parsing/parser.mly"
( _1 )
-# 31047 "parsing/parser.ml"
+# 31767 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.expression) =
-# 2024 "parsing/parser.mly"
+# 2074 "parsing/parser.mly"
( _1 )
-# 31079 "parsing/parser.ml"
+# 31799 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__3_ in
let _v : (Parsetree.expression) = let _1 =
let _1 =
-# 2026 "parsing/parser.mly"
+# 2076 "parsing/parser.mly"
( Pexp_sequence(_1, _3) )
-# 31119 "parsing/parser.ml"
+# 31839 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 31128 "parsing/parser.ml"
+# 31848 "parsing/parser.ml"
in
-# 2027 "parsing/parser.mly"
+# 2077 "parsing/parser.mly"
( _1 )
-# 31134 "parsing/parser.ml"
+# 31854 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2029 "parsing/parser.mly"
+# 2079 "parsing/parser.mly"
( let seq = mkexp ~loc:_sloc (Pexp_sequence (_1, _5)) in
let payload = PStr [mkstrexp seq []] in
mkexp ~loc:_sloc (Pexp_extension (_4, payload)) )
-# 31192 "parsing/parser.ml"
+# 31912 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in
let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in
let args_res : (Parsetree.constructor_arguments * Parsetree.core_type option) = Obj.magic args_res in
- let _1_inlined2 : (string) = Obj.magic _1_inlined2 in
+ let _1_inlined2 : (Asttypes.label) = Obj.magic _1_inlined2 in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
let ext : (string Asttypes.loc option) = Obj.magic ext in
let _1 : unit = Obj.magic _1 in
let _v : (Parsetree.type_exception * string Asttypes.loc option) = let attrs =
let _1 = _1_inlined4 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 31261 "parsing/parser.ml"
+# 31981 "parsing/parser.ml"
in
let _endpos_attrs_ = _endpos__1_inlined4_ in
let attrs2 =
let _1 = _1_inlined3 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 31270 "parsing/parser.ml"
+# 31990 "parsing/parser.ml"
in
let id =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 31281 "parsing/parser.ml"
+# 32001 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 31289 "parsing/parser.ml"
+# 32009 "parsing/parser.ml"
in
let _endpos = _endpos_attrs_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2960 "parsing/parser.mly"
+# 3010 "parsing/parser.mly"
( let args, res = args_res in
let loc = make_loc _sloc in
let docs = symbol_docs _sloc in
Te.mk_exception ~attrs
(Te.decl id ~args ?res ~attrs:(attrs1 @ attrs2) ~loc ~docs)
, ext )
-# 31303 "parsing/parser.ml"
+# 32023 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos_xss_ in
let _v : (Parsetree.signature) = let _1 =
let _1 =
-# 260 "menhir/standard.mly"
+# 260 "<standard.mly>"
( List.flatten xss )
-# 31329 "parsing/parser.ml"
+# 32049 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in
let _endpos = _endpos__1_ in
let _startpos = _startpos__1_ in
-# 785 "parsing/parser.mly"
+# 806 "parsing/parser.mly"
( extra_sig _startpos _endpos _1 )
-# 31337 "parsing/parser.ml"
+# 32057 "parsing/parser.ml"
in
-# 1492 "parsing/parser.mly"
+# 1542 "parsing/parser.mly"
( _1 )
-# 31343 "parsing/parser.ml"
+# 32063 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.signature_item) = let _2 =
let _1 = _1_inlined1 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 31377 "parsing/parser.ml"
+# 32097 "parsing/parser.ml"
in
let _endpos__2_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1507 "parsing/parser.mly"
+# 1557 "parsing/parser.mly"
( let docs = symbol_docs _sloc in
mksig ~loc:_sloc (Psig_extension (_1, (add_docs_attrs docs _2))) )
-# 31388 "parsing/parser.ml"
+# 32108 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.signature_item) = let _1 =
let _1 =
-# 1511 "parsing/parser.mly"
+# 1561 "parsing/parser.mly"
( Psig_attribute _1 )
-# 31414 "parsing/parser.ml"
+# 32134 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 833 "parsing/parser.mly"
+# 854 "parsing/parser.mly"
( mksig ~loc:_sloc _1 )
-# 31422 "parsing/parser.ml"
+# 32142 "parsing/parser.ml"
in
-# 1513 "parsing/parser.mly"
+# 1563 "parsing/parser.mly"
( _1 )
-# 31428 "parsing/parser.ml"
+# 32148 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.signature_item) = let _1 =
let _1 =
-# 1516 "parsing/parser.mly"
+# 1566 "parsing/parser.mly"
( psig_value _1 )
-# 31454 "parsing/parser.ml"
+# 32174 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 850 "parsing/parser.mly"
+# 871 "parsing/parser.mly"
( wrap_mksig_ext ~loc:_sloc _1 )
-# 31462 "parsing/parser.ml"
+# 32182 "parsing/parser.ml"
in
-# 1546 "parsing/parser.mly"
+# 1596 "parsing/parser.mly"
( _1 )
-# 31468 "parsing/parser.ml"
+# 32188 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.signature_item) = let _1 =
let _1 =
-# 1518 "parsing/parser.mly"
+# 1568 "parsing/parser.mly"
( psig_value _1 )
-# 31494 "parsing/parser.ml"
+# 32214 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 850 "parsing/parser.mly"
+# 871 "parsing/parser.mly"
( wrap_mksig_ext ~loc:_sloc _1 )
-# 31502 "parsing/parser.ml"
+# 32222 "parsing/parser.ml"
in
-# 1546 "parsing/parser.mly"
+# 1596 "parsing/parser.mly"
( _1 )
-# 31508 "parsing/parser.ml"
+# 32228 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _1 =
let _1 =
-# 1023 "parsing/parser.mly"
+# 1044 "parsing/parser.mly"
( let (x, b) = a in x, b :: bs )
-# 31545 "parsing/parser.ml"
+# 32265 "parsing/parser.ml"
in
-# 2792 "parsing/parser.mly"
+# 2842 "parsing/parser.mly"
( _1 )
-# 31550 "parsing/parser.ml"
+# 32270 "parsing/parser.ml"
in
-# 2775 "parsing/parser.mly"
+# 2825 "parsing/parser.mly"
( _1 )
-# 31556 "parsing/parser.ml"
+# 32276 "parsing/parser.ml"
in
-# 1520 "parsing/parser.mly"
+# 1570 "parsing/parser.mly"
( psig_type _1 )
-# 31562 "parsing/parser.ml"
+# 32282 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_bs_, _startpos_a_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 850 "parsing/parser.mly"
+# 871 "parsing/parser.mly"
( wrap_mksig_ext ~loc:_sloc _1 )
-# 31572 "parsing/parser.ml"
+# 32292 "parsing/parser.ml"
in
-# 1546 "parsing/parser.mly"
+# 1596 "parsing/parser.mly"
( _1 )
-# 31578 "parsing/parser.ml"
+# 32298 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _1 =
let _1 =
-# 1023 "parsing/parser.mly"
+# 1044 "parsing/parser.mly"
( let (x, b) = a in x, b :: bs )
-# 31615 "parsing/parser.ml"
+# 32335 "parsing/parser.ml"
in
-# 2792 "parsing/parser.mly"
+# 2842 "parsing/parser.mly"
( _1 )
-# 31620 "parsing/parser.ml"
+# 32340 "parsing/parser.ml"
in
-# 2780 "parsing/parser.mly"
+# 2830 "parsing/parser.mly"
( _1 )
-# 31626 "parsing/parser.ml"
+# 32346 "parsing/parser.ml"
in
-# 1522 "parsing/parser.mly"
+# 1572 "parsing/parser.mly"
( psig_typesubst _1 )
-# 31632 "parsing/parser.ml"
+# 32352 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_bs_, _startpos_a_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 850 "parsing/parser.mly"
+# 871 "parsing/parser.mly"
( wrap_mksig_ext ~loc:_sloc _1 )
-# 31642 "parsing/parser.ml"
+# 32362 "parsing/parser.ml"
in
-# 1546 "parsing/parser.mly"
+# 1596 "parsing/parser.mly"
( _1 )
-# 31648 "parsing/parser.ml"
+# 32368 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 31735 "parsing/parser.ml"
+# 32455 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let cs =
-# 1015 "parsing/parser.mly"
+# 1036 "parsing/parser.mly"
( List.rev xs )
-# 31742 "parsing/parser.ml"
+# 32462 "parsing/parser.ml"
in
let tid =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 31752 "parsing/parser.ml"
+# 32472 "parsing/parser.ml"
in
let _4 =
-# 3512 "parsing/parser.mly"
+# 3574 "parsing/parser.mly"
( Recursive )
-# 31758 "parsing/parser.ml"
+# 32478 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 31765 "parsing/parser.ml"
+# 32485 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3029 "parsing/parser.mly"
+# 3079 "parsing/parser.mly"
( let docs = symbol_docs _sloc in
let attrs = attrs1 @ attrs2 in
Te.mk tid cs ~params ~priv ~attrs ~docs,
ext )
-# 31777 "parsing/parser.ml"
+# 32497 "parsing/parser.ml"
in
-# 3016 "parsing/parser.mly"
+# 3066 "parsing/parser.mly"
( _1 )
-# 31783 "parsing/parser.ml"
+# 32503 "parsing/parser.ml"
in
-# 1524 "parsing/parser.mly"
+# 1574 "parsing/parser.mly"
( psig_typext _1 )
-# 31789 "parsing/parser.ml"
+# 32509 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 850 "parsing/parser.mly"
+# 871 "parsing/parser.mly"
( wrap_mksig_ext ~loc:_sloc _1 )
-# 31799 "parsing/parser.ml"
+# 32519 "parsing/parser.ml"
in
-# 1546 "parsing/parser.mly"
+# 1596 "parsing/parser.mly"
( _1 )
-# 31805 "parsing/parser.ml"
+# 32525 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs2 =
let _1 = _1_inlined4 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 31899 "parsing/parser.ml"
+# 32619 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined4_ in
let cs =
-# 1015 "parsing/parser.mly"
+# 1036 "parsing/parser.mly"
( List.rev xs )
-# 31906 "parsing/parser.ml"
+# 32626 "parsing/parser.ml"
in
let tid =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 31916 "parsing/parser.ml"
+# 32636 "parsing/parser.ml"
in
let _4 =
let _startpos = _startpos__1_ in
let _loc = (_startpos, _endpos) in
-# 3513 "parsing/parser.mly"
+# 3575 "parsing/parser.mly"
( not_expecting _loc "nonrec flag" )
-# 31927 "parsing/parser.ml"
+# 32647 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 31935 "parsing/parser.ml"
+# 32655 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3029 "parsing/parser.mly"
+# 3079 "parsing/parser.mly"
( let docs = symbol_docs _sloc in
let attrs = attrs1 @ attrs2 in
Te.mk tid cs ~params ~priv ~attrs ~docs,
ext )
-# 31947 "parsing/parser.ml"
+# 32667 "parsing/parser.ml"
in
-# 3016 "parsing/parser.mly"
+# 3066 "parsing/parser.mly"
( _1 )
-# 31953 "parsing/parser.ml"
+# 32673 "parsing/parser.ml"
in
-# 1524 "parsing/parser.mly"
+# 1574 "parsing/parser.mly"
( psig_typext _1 )
-# 31959 "parsing/parser.ml"
+# 32679 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 850 "parsing/parser.mly"
+# 871 "parsing/parser.mly"
( wrap_mksig_ext ~loc:_sloc _1 )
-# 31969 "parsing/parser.ml"
+# 32689 "parsing/parser.ml"
in
-# 1546 "parsing/parser.mly"
+# 1596 "parsing/parser.mly"
( _1 )
-# 31975 "parsing/parser.ml"
+# 32695 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.signature_item) = let _1 =
let _1 =
-# 1526 "parsing/parser.mly"
+# 1576 "parsing/parser.mly"
( psig_exception _1 )
-# 32001 "parsing/parser.ml"
+# 32721 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 850 "parsing/parser.mly"
+# 871 "parsing/parser.mly"
( wrap_mksig_ext ~loc:_sloc _1 )
-# 32009 "parsing/parser.ml"
+# 32729 "parsing/parser.ml"
in
-# 1546 "parsing/parser.mly"
+# 1596 "parsing/parser.mly"
( _1 )
-# 32015 "parsing/parser.ml"
+# 32735 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 32080 "parsing/parser.ml"
+# 32800 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 32092 "parsing/parser.ml"
+# 32812 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 32100 "parsing/parser.ml"
+# 32820 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1555 "parsing/parser.mly"
+# 1605 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
let docs = symbol_docs _sloc in
Md.mk name body ~attrs ~loc ~docs, ext
)
-# 32114 "parsing/parser.ml"
+# 32834 "parsing/parser.ml"
in
-# 1528 "parsing/parser.mly"
+# 1578 "parsing/parser.mly"
( let (body, ext) = _1 in (Psig_module body, ext) )
-# 32120 "parsing/parser.ml"
+# 32840 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 850 "parsing/parser.mly"
+# 871 "parsing/parser.mly"
( wrap_mksig_ext ~loc:_sloc _1 )
-# 32130 "parsing/parser.ml"
+# 32850 "parsing/parser.ml"
in
-# 1546 "parsing/parser.mly"
+# 1596 "parsing/parser.mly"
( _1 )
-# 32136 "parsing/parser.ml"
+# 32856 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs2 =
let _1 = _1_inlined4 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 32208 "parsing/parser.ml"
+# 32928 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 32221 "parsing/parser.ml"
+# 32941 "parsing/parser.ml"
in
let (_endpos_id_, _startpos_id_) = (_endpos__1_, _startpos__1_) in
let _symbolstartpos = _startpos_id_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1591 "parsing/parser.mly"
+# 1641 "parsing/parser.mly"
( Mty.alias ~loc:(make_loc _sloc) id )
-# 32231 "parsing/parser.ml"
+# 32951 "parsing/parser.ml"
in
let name =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 32242 "parsing/parser.ml"
+# 32962 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 32250 "parsing/parser.ml"
+# 32970 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1582 "parsing/parser.mly"
+# 1632 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
let docs = symbol_docs _sloc in
Md.mk name body ~attrs ~loc ~docs, ext
)
-# 32264 "parsing/parser.ml"
+# 32984 "parsing/parser.ml"
in
-# 1530 "parsing/parser.mly"
+# 1580 "parsing/parser.mly"
( let (body, ext) = _1 in (Psig_module body, ext) )
-# 32270 "parsing/parser.ml"
+# 32990 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 850 "parsing/parser.mly"
+# 871 "parsing/parser.mly"
( wrap_mksig_ext ~loc:_sloc _1 )
-# 32280 "parsing/parser.ml"
+# 33000 "parsing/parser.ml"
in
-# 1546 "parsing/parser.mly"
+# 1596 "parsing/parser.mly"
( _1 )
-# 32286 "parsing/parser.ml"
+# 33006 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.signature_item) = let _1 =
let _1 =
-# 1532 "parsing/parser.mly"
+# 1582 "parsing/parser.mly"
( let (body, ext) = _1 in (Psig_modsubst body, ext) )
-# 32312 "parsing/parser.ml"
+# 33032 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 850 "parsing/parser.mly"
+# 871 "parsing/parser.mly"
( wrap_mksig_ext ~loc:_sloc _1 )
-# 32320 "parsing/parser.ml"
+# 33040 "parsing/parser.ml"
in
-# 1546 "parsing/parser.mly"
+# 1596 "parsing/parser.mly"
( _1 )
-# 32326 "parsing/parser.ml"
+# 33046 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 32414 "parsing/parser.ml"
+# 33134 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 32426 "parsing/parser.ml"
+# 33146 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 32434 "parsing/parser.ml"
+# 33154 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1625 "parsing/parser.mly"
+# 1675 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
let docs = symbol_docs _sloc in
ext, Md.mk name mty ~attrs ~loc ~docs
)
-# 32448 "parsing/parser.ml"
+# 33168 "parsing/parser.ml"
in
-# 1023 "parsing/parser.mly"
+# 1044 "parsing/parser.mly"
( let (x, b) = a in x, b :: bs )
-# 32454 "parsing/parser.ml"
+# 33174 "parsing/parser.ml"
in
-# 1614 "parsing/parser.mly"
+# 1664 "parsing/parser.mly"
( _1 )
-# 32460 "parsing/parser.ml"
+# 33180 "parsing/parser.ml"
in
-# 1534 "parsing/parser.mly"
+# 1584 "parsing/parser.mly"
( let (ext, l) = _1 in (Psig_recmodule l, ext) )
-# 32466 "parsing/parser.ml"
+# 33186 "parsing/parser.ml"
in
let _endpos__1_ = _endpos_bs_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 850 "parsing/parser.mly"
+# 871 "parsing/parser.mly"
( wrap_mksig_ext ~loc:_sloc _1 )
-# 32476 "parsing/parser.ml"
+# 33196 "parsing/parser.ml"
in
-# 1546 "parsing/parser.mly"
+# 1596 "parsing/parser.mly"
( _1 )
-# 32482 "parsing/parser.ml"
+# 33202 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.signature_item) = let _1 =
let _1 =
-# 1536 "parsing/parser.mly"
+# 1586 "parsing/parser.mly"
( let (body, ext) = _1 in (Psig_modtype body, ext) )
-# 32508 "parsing/parser.ml"
+# 33228 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 850 "parsing/parser.mly"
+# 871 "parsing/parser.mly"
( wrap_mksig_ext ~loc:_sloc _1 )
-# 32516 "parsing/parser.ml"
+# 33236 "parsing/parser.ml"
in
-# 1546 "parsing/parser.mly"
+# 1596 "parsing/parser.mly"
( _1 )
-# 32522 "parsing/parser.ml"
+# 33242 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.signature_item) = let _1 =
let _1 =
-# 1538 "parsing/parser.mly"
+# 1588 "parsing/parser.mly"
( let (body, ext) = _1 in (Psig_open body, ext) )
-# 32548 "parsing/parser.ml"
+# 33268 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 850 "parsing/parser.mly"
+# 871 "parsing/parser.mly"
( wrap_mksig_ext ~loc:_sloc _1 )
-# 32556 "parsing/parser.ml"
+# 33276 "parsing/parser.ml"
in
-# 1546 "parsing/parser.mly"
+# 1596 "parsing/parser.mly"
( _1 )
-# 32562 "parsing/parser.ml"
+# 33282 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs2 =
let _1 = _1_inlined2 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 32620 "parsing/parser.ml"
+# 33340 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined2_ in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 32629 "parsing/parser.ml"
+# 33349 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1384 "parsing/parser.mly"
+# 1434 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
let docs = symbol_docs _sloc in
Incl.mk thing ~attrs ~loc ~docs, ext
)
-# 32643 "parsing/parser.ml"
+# 33363 "parsing/parser.ml"
in
-# 1540 "parsing/parser.mly"
+# 1590 "parsing/parser.mly"
( psig_include _1 )
-# 32649 "parsing/parser.ml"
+# 33369 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 850 "parsing/parser.mly"
+# 871 "parsing/parser.mly"
( wrap_mksig_ext ~loc:_sloc _1 )
-# 32659 "parsing/parser.ml"
+# 33379 "parsing/parser.ml"
in
-# 1546 "parsing/parser.mly"
+# 1596 "parsing/parser.mly"
( _1 )
-# 32665 "parsing/parser.ml"
+# 33385 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let cty : (Parsetree.class_type) = Obj.magic cty in
let _7 : unit = Obj.magic _7 in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 32744 "parsing/parser.ml"
+# 33464 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in
let virt : (Asttypes.virtual_flag) = Obj.magic virt in
let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 32764 "parsing/parser.ml"
+# 33484 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 32776 "parsing/parser.ml"
+# 33496 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 32784 "parsing/parser.ml"
+# 33504 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1955 "parsing/parser.mly"
+# 2005 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
ext,
Ci.mk id cty ~virt ~params ~attrs ~loc ~docs
)
-# 32799 "parsing/parser.ml"
+# 33519 "parsing/parser.ml"
in
-# 1023 "parsing/parser.mly"
+# 1044 "parsing/parser.mly"
( let (x, b) = a in x, b :: bs )
-# 32805 "parsing/parser.ml"
+# 33525 "parsing/parser.ml"
in
-# 1943 "parsing/parser.mly"
+# 1993 "parsing/parser.mly"
( _1 )
-# 32811 "parsing/parser.ml"
+# 33531 "parsing/parser.ml"
in
-# 1542 "parsing/parser.mly"
+# 1592 "parsing/parser.mly"
( let (ext, l) = _1 in (Psig_class l, ext) )
-# 32817 "parsing/parser.ml"
+# 33537 "parsing/parser.ml"
in
let _endpos__1_ = _endpos_bs_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 850 "parsing/parser.mly"
+# 871 "parsing/parser.mly"
( wrap_mksig_ext ~loc:_sloc _1 )
-# 32827 "parsing/parser.ml"
+# 33547 "parsing/parser.ml"
in
-# 1546 "parsing/parser.mly"
+# 1596 "parsing/parser.mly"
( _1 )
-# 32833 "parsing/parser.ml"
+# 33553 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.signature_item) = let _1 =
let _1 =
-# 1544 "parsing/parser.mly"
+# 1594 "parsing/parser.mly"
( let (ext, l) = _1 in (Psig_class_type l, ext) )
-# 32859 "parsing/parser.ml"
+# 33579 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 850 "parsing/parser.mly"
+# 871 "parsing/parser.mly"
( wrap_mksig_ext ~loc:_sloc _1 )
-# 32867 "parsing/parser.ml"
+# 33587 "parsing/parser.ml"
in
-# 1546 "parsing/parser.mly"
+# 1596 "parsing/parser.mly"
( _1 )
-# 32873 "parsing/parser.ml"
+# 33593 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.constant) =
-# 3355 "parsing/parser.mly"
+# 3405 "parsing/parser.mly"
( _1 )
-# 32898 "parsing/parser.ml"
+# 33618 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 628 "parsing/parser.mly"
+# 633 "parsing/parser.mly"
(string * char option)
-# 32925 "parsing/parser.ml"
+# 33645 "parsing/parser.ml"
) = Obj.magic _2 in
let _1 : unit = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.constant) =
-# 3356 "parsing/parser.mly"
+# 3406 "parsing/parser.mly"
( let (n, m) = _2 in Pconst_integer("-" ^ n, m) )
-# 32934 "parsing/parser.ml"
+# 33654 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 607 "parsing/parser.mly"
+# 612 "parsing/parser.mly"
(string * char option)
-# 32961 "parsing/parser.ml"
+# 33681 "parsing/parser.ml"
) = Obj.magic _2 in
let _1 : unit = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.constant) =
-# 3357 "parsing/parser.mly"
+# 3407 "parsing/parser.mly"
( let (f, m) = _2 in Pconst_float("-" ^ f, m) )
-# 32970 "parsing/parser.ml"
+# 33690 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 628 "parsing/parser.mly"
+# 633 "parsing/parser.mly"
(string * char option)
-# 32997 "parsing/parser.ml"
+# 33717 "parsing/parser.ml"
) = Obj.magic _2 in
let _1 : unit = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.constant) =
-# 3358 "parsing/parser.mly"
+# 3408 "parsing/parser.mly"
( let (n, m) = _2 in Pconst_integer (n, m) )
-# 33006 "parsing/parser.ml"
+# 33726 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 607 "parsing/parser.mly"
+# 612 "parsing/parser.mly"
(string * char option)
-# 33033 "parsing/parser.ml"
+# 33753 "parsing/parser.ml"
) = Obj.magic _2 in
let _1 : unit = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.constant) =
-# 3359 "parsing/parser.mly"
+# 3409 "parsing/parser.mly"
( let (f, m) = _2 in Pconst_float(f, m) )
-# 33042 "parsing/parser.ml"
+# 33762 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 2707 "parsing/parser.mly"
+# 2757 "parsing/parser.mly"
( let fields, closed = _1 in
let closed = match closed with Some () -> Open | None -> Closed in
fields, closed )
-# 33087 "parsing/parser.ml"
+# 33807 "parsing/parser.ml"
in
-# 2678 "parsing/parser.mly"
+# 2728 "parsing/parser.mly"
( let (fields, closed) = _2 in
Ppat_record(fields, closed) )
-# 33094 "parsing/parser.ml"
+# 33814 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 33104 "parsing/parser.ml"
+# 33824 "parsing/parser.ml"
in
-# 2692 "parsing/parser.mly"
+# 2742 "parsing/parser.mly"
( _1 )
-# 33110 "parsing/parser.ml"
+# 33830 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 2707 "parsing/parser.mly"
+# 2757 "parsing/parser.mly"
( let fields, closed = _1 in
let closed = match closed with Some () -> Open | None -> Closed in
fields, closed )
-# 33155 "parsing/parser.ml"
+# 33875 "parsing/parser.ml"
in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2681 "parsing/parser.mly"
+# 2731 "parsing/parser.mly"
( unclosed "{" _loc__1_ "}" _loc__3_ )
-# 33163 "parsing/parser.ml"
+# 33883 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 33173 "parsing/parser.ml"
+# 33893 "parsing/parser.ml"
in
-# 2692 "parsing/parser.mly"
+# 2742 "parsing/parser.mly"
( _1 )
-# 33179 "parsing/parser.ml"
+# 33899 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.pattern) = let _1 =
let _1 =
let _2 =
-# 2701 "parsing/parser.mly"
+# 2751 "parsing/parser.mly"
( ps )
-# 33220 "parsing/parser.ml"
+# 33940 "parsing/parser.ml"
in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2683 "parsing/parser.mly"
+# 2733 "parsing/parser.mly"
( fst (mktailpat _loc__3_ _2) )
-# 33226 "parsing/parser.ml"
+# 33946 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 33236 "parsing/parser.ml"
+# 33956 "parsing/parser.ml"
in
-# 2692 "parsing/parser.mly"
+# 2742 "parsing/parser.mly"
( _1 )
-# 33242 "parsing/parser.ml"
+# 33962 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.pattern) = let _1 =
let _1 =
let _2 =
-# 2701 "parsing/parser.mly"
+# 2751 "parsing/parser.mly"
( ps )
-# 33283 "parsing/parser.ml"
+# 34003 "parsing/parser.ml"
in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2685 "parsing/parser.mly"
+# 2735 "parsing/parser.mly"
( unclosed "[" _loc__1_ "]" _loc__3_ )
-# 33290 "parsing/parser.ml"
+# 34010 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 33300 "parsing/parser.ml"
+# 34020 "parsing/parser.ml"
in
-# 2692 "parsing/parser.mly"
+# 2742 "parsing/parser.mly"
( _1 )
-# 33306 "parsing/parser.ml"
+# 34026 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.pattern) = let _1 =
let _1 =
let _2 =
-# 2701 "parsing/parser.mly"
+# 2751 "parsing/parser.mly"
( ps )
-# 33347 "parsing/parser.ml"
+# 34067 "parsing/parser.ml"
in
-# 2687 "parsing/parser.mly"
+# 2737 "parsing/parser.mly"
( Ppat_array _2 )
-# 33352 "parsing/parser.ml"
+# 34072 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 33362 "parsing/parser.ml"
+# 34082 "parsing/parser.ml"
in
-# 2692 "parsing/parser.mly"
+# 2742 "parsing/parser.mly"
( _1 )
-# 33368 "parsing/parser.ml"
+# 34088 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__2_ in
let _v : (Parsetree.pattern) = let _1 =
let _1 =
-# 2689 "parsing/parser.mly"
+# 2739 "parsing/parser.mly"
( Ppat_array [] )
-# 33401 "parsing/parser.ml"
+# 34121 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 33410 "parsing/parser.ml"
+# 34130 "parsing/parser.ml"
in
-# 2692 "parsing/parser.mly"
+# 2742 "parsing/parser.mly"
( _1 )
-# 33416 "parsing/parser.ml"
+# 34136 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.pattern) = let _1 =
let _1 =
let _2 =
-# 2701 "parsing/parser.mly"
+# 2751 "parsing/parser.mly"
( ps )
-# 33457 "parsing/parser.ml"
+# 34177 "parsing/parser.ml"
in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2691 "parsing/parser.mly"
+# 2741 "parsing/parser.mly"
( unclosed "[|" _loc__1_ "|]" _loc__3_ )
-# 33464 "parsing/parser.ml"
+# 34184 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 33474 "parsing/parser.ml"
+# 34194 "parsing/parser.ml"
in
-# 2692 "parsing/parser.mly"
+# 2742 "parsing/parser.mly"
( _1 )
-# 33480 "parsing/parser.ml"
+# 34200 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2190 "parsing/parser.mly"
+# 2240 "parsing/parser.mly"
( reloc_exp ~loc:_sloc _2 )
-# 33522 "parsing/parser.ml"
+# 34242 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression) = let _loc__3_ = (_startpos__3_, _endpos__3_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2192 "parsing/parser.mly"
+# 2242 "parsing/parser.mly"
( unclosed "(" _loc__1_ ")" _loc__3_ )
-# 33563 "parsing/parser.ml"
+# 34283 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2194 "parsing/parser.mly"
+# 2244 "parsing/parser.mly"
( mkexp_constraint ~loc:_sloc _2 _3 )
-# 33612 "parsing/parser.ml"
+# 34332 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2196 "parsing/parser.mly"
+# 2246 "parsing/parser.mly"
( array_get ~loc:_sloc _1 _4 )
-# 33668 "parsing/parser.ml"
+# 34388 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression) = let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2198 "parsing/parser.mly"
+# 2248 "parsing/parser.mly"
( unclosed "(" _loc__3_ ")" _loc__5_ )
-# 33723 "parsing/parser.ml"
+# 34443 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2200 "parsing/parser.mly"
+# 2250 "parsing/parser.mly"
( string_get ~loc:_sloc _1 _4 )
-# 33779 "parsing/parser.ml"
+# 34499 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression) = let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2202 "parsing/parser.mly"
+# 2252 "parsing/parser.mly"
( unclosed "[" _loc__3_ "]" _loc__5_ )
-# 33834 "parsing/parser.ml"
+# 34554 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _3 : unit = Obj.magic _3 in
let _2 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 33882 "parsing/parser.ml"
+# 34602 "parsing/parser.ml"
) = Obj.magic _2 in
let _1 : (Parsetree.expression) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : (Parsetree.expression) = let _4 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 33891 "parsing/parser.ml"
+# 34611 "parsing/parser.ml"
in
let _endpos = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2204 "parsing/parser.mly"
+# 2254 "parsing/parser.mly"
( dotop_get ~loc:_sloc lident bracket _2 _1 _4 )
-# 33899 "parsing/parser.ml"
+# 34619 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _3 : unit = Obj.magic _3 in
let _2 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 33947 "parsing/parser.ml"
+# 34667 "parsing/parser.ml"
) = Obj.magic _2 in
let _1 : (Parsetree.expression) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : (Parsetree.expression) = let _4 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 33956 "parsing/parser.ml"
+# 34676 "parsing/parser.ml"
in
let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2206 "parsing/parser.mly"
+# 2256 "parsing/parser.mly"
( unclosed "[" _loc__3_ "]" _loc__5_ )
-# 33963 "parsing/parser.ml"
+# 34683 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _3 : unit = Obj.magic _3 in
let _2 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 34011 "parsing/parser.ml"
+# 34731 "parsing/parser.ml"
) = Obj.magic _2 in
let _1 : (Parsetree.expression) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : (Parsetree.expression) = let _4 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 34020 "parsing/parser.ml"
+# 34740 "parsing/parser.ml"
in
let _endpos = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2208 "parsing/parser.mly"
+# 2258 "parsing/parser.mly"
( dotop_get ~loc:_sloc lident paren _2 _1 _4 )
-# 34028 "parsing/parser.ml"
+# 34748 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _3 : unit = Obj.magic _3 in
let _2 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 34076 "parsing/parser.ml"
+# 34796 "parsing/parser.ml"
) = Obj.magic _2 in
let _1 : (Parsetree.expression) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : (Parsetree.expression) = let _4 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 34085 "parsing/parser.ml"
+# 34805 "parsing/parser.ml"
in
let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2210 "parsing/parser.mly"
+# 2260 "parsing/parser.mly"
( unclosed "(" _loc__3_ ")" _loc__5_ )
-# 34092 "parsing/parser.ml"
+# 34812 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _3 : unit = Obj.magic _3 in
let _2 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 34140 "parsing/parser.ml"
+# 34860 "parsing/parser.ml"
) = Obj.magic _2 in
let _1 : (Parsetree.expression) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : (Parsetree.expression) = let _4 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 34149 "parsing/parser.ml"
+# 34869 "parsing/parser.ml"
in
let _endpos = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2212 "parsing/parser.mly"
+# 2262 "parsing/parser.mly"
( dotop_get ~loc:_sloc lident brace _2 _1 _4 )
-# 34157 "parsing/parser.ml"
+# 34877 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _4 : (Parsetree.expression) = Obj.magic _4 in
let _3 : unit = Obj.magic _3 in
let _2 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 34205 "parsing/parser.ml"
+# 34925 "parsing/parser.ml"
) = Obj.magic _2 in
let _1 : (Parsetree.expression) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _v : (Parsetree.expression) = let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2214 "parsing/parser.mly"
+# 2264 "parsing/parser.mly"
( unclosed "{" _loc__3_ "}" _loc__5_ )
-# 34216 "parsing/parser.ml"
+# 34936 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _5 : unit = Obj.magic _5 in
let _4 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 34276 "parsing/parser.ml"
+# 34996 "parsing/parser.ml"
) = Obj.magic _4 in
let _3 : (Longident.t) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : (Parsetree.expression) = let _6 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 34287 "parsing/parser.ml"
+# 35007 "parsing/parser.ml"
in
let _endpos = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2216 "parsing/parser.mly"
+# 2266 "parsing/parser.mly"
( dotop_get ~loc:_sloc (ldot _3) bracket _4 _1 _6 )
-# 34295 "parsing/parser.ml"
+# 35015 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _5 : unit = Obj.magic _5 in
let _4 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 34355 "parsing/parser.ml"
+# 35075 "parsing/parser.ml"
) = Obj.magic _4 in
let _3 : (Longident.t) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : (Parsetree.expression) = let _6 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 34366 "parsing/parser.ml"
+# 35086 "parsing/parser.ml"
in
let _loc__7_ = (_startpos__7_, _endpos__7_) in
let _loc__5_ = (_startpos__5_, _endpos__5_) in
-# 2219 "parsing/parser.mly"
+# 2269 "parsing/parser.mly"
( unclosed "[" _loc__5_ "]" _loc__7_ )
-# 34373 "parsing/parser.ml"
+# 35093 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _5 : unit = Obj.magic _5 in
let _4 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 34433 "parsing/parser.ml"
+# 35153 "parsing/parser.ml"
) = Obj.magic _4 in
let _3 : (Longident.t) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : (Parsetree.expression) = let _6 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 34444 "parsing/parser.ml"
+# 35164 "parsing/parser.ml"
in
let _endpos = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2221 "parsing/parser.mly"
+# 2271 "parsing/parser.mly"
( dotop_get ~loc:_sloc (ldot _3) paren _4 _1 _6 )
-# 34452 "parsing/parser.ml"
+# 35172 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _5 : unit = Obj.magic _5 in
let _4 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 34512 "parsing/parser.ml"
+# 35232 "parsing/parser.ml"
) = Obj.magic _4 in
let _3 : (Longident.t) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : (Parsetree.expression) = let _6 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 34523 "parsing/parser.ml"
+# 35243 "parsing/parser.ml"
in
let _loc__7_ = (_startpos__7_, _endpos__7_) in
let _loc__5_ = (_startpos__5_, _endpos__5_) in
-# 2224 "parsing/parser.mly"
+# 2274 "parsing/parser.mly"
( unclosed "(" _loc__5_ ")" _loc__7_ )
-# 34530 "parsing/parser.ml"
+# 35250 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _5 : unit = Obj.magic _5 in
let _4 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 34590 "parsing/parser.ml"
+# 35310 "parsing/parser.ml"
) = Obj.magic _4 in
let _3 : (Longident.t) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : (Parsetree.expression) = let _6 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 34601 "parsing/parser.ml"
+# 35321 "parsing/parser.ml"
in
let _endpos = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2226 "parsing/parser.mly"
+# 2276 "parsing/parser.mly"
( dotop_get ~loc:_sloc (ldot _3) brace _4 _1 _6 )
-# 34609 "parsing/parser.ml"
+# 35329 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let es : (Parsetree.expression list) = Obj.magic es in
let _5 : unit = Obj.magic _5 in
let _4 : (
-# 623 "parsing/parser.mly"
+# 628 "parsing/parser.mly"
(string)
-# 34669 "parsing/parser.ml"
+# 35389 "parsing/parser.ml"
) = Obj.magic _4 in
let _3 : (Longident.t) = Obj.magic _3 in
let _2 : unit = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : (Parsetree.expression) = let _6 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 34680 "parsing/parser.ml"
+# 35400 "parsing/parser.ml"
in
let _loc__7_ = (_startpos__7_, _endpos__7_) in
let _loc__5_ = (_startpos__5_, _endpos__5_) in
-# 2229 "parsing/parser.mly"
+# 2279 "parsing/parser.mly"
( unclosed "{" _loc__5_ "}" _loc__7_ )
-# 34687 "parsing/parser.ml"
+# 35407 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2231 "parsing/parser.mly"
+# 2281 "parsing/parser.mly"
( bigarray_get ~loc:_sloc _1 _4 )
-# 34743 "parsing/parser.ml"
+# 35463 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression) = let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2233 "parsing/parser.mly"
+# 2283 "parsing/parser.mly"
( unclosed "{" _loc__3_ "}" _loc__5_ )
-# 34798 "parsing/parser.ml"
+# 35518 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 34854 "parsing/parser.ml"
+# 35574 "parsing/parser.ml"
in
-# 2242 "parsing/parser.mly"
+# 2292 "parsing/parser.mly"
( e.pexp_desc, (ext, attrs @ e.pexp_attributes) )
-# 34860 "parsing/parser.ml"
+# 35580 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2235 "parsing/parser.mly"
+# 2285 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 34871 "parsing/parser.ml"
+# 35591 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 34922 "parsing/parser.ml"
+# 35642 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 34928 "parsing/parser.ml"
+# 35648 "parsing/parser.ml"
in
let _endpos = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2244 "parsing/parser.mly"
+# 2294 "parsing/parser.mly"
( Pexp_construct (mkloc (Lident "()") (make_loc _sloc), None), _2 )
-# 34937 "parsing/parser.ml"
+# 35657 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2235 "parsing/parser.mly"
+# 2285 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 34948 "parsing/parser.ml"
+# 35668 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 35006 "parsing/parser.ml"
+# 35726 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 35012 "parsing/parser.ml"
+# 35732 "parsing/parser.ml"
in
let _loc__4_ = (_startpos__4_, _endpos__4_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2246 "parsing/parser.mly"
+# 2296 "parsing/parser.mly"
( unclosed "begin" _loc__1_ "end" _loc__4_ )
-# 35020 "parsing/parser.ml"
+# 35740 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2235 "parsing/parser.mly"
+# 2285 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 35031 "parsing/parser.ml"
+# 35751 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 35083 "parsing/parser.ml"
+# 35803 "parsing/parser.ml"
in
let _2 =
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 35093 "parsing/parser.ml"
+# 35813 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 35099 "parsing/parser.ml"
+# 35819 "parsing/parser.ml"
in
-# 2248 "parsing/parser.mly"
+# 2298 "parsing/parser.mly"
( Pexp_new(_3), _2 )
-# 35105 "parsing/parser.ml"
+# 35825 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2235 "parsing/parser.mly"
+# 2285 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 35116 "parsing/parser.ml"
+# 35836 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 35181 "parsing/parser.ml"
+# 35901 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 35187 "parsing/parser.ml"
+# 35907 "parsing/parser.ml"
in
-# 2250 "parsing/parser.mly"
+# 2300 "parsing/parser.mly"
( Pexp_pack _4, _3 )
-# 35193 "parsing/parser.ml"
+# 35913 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2235 "parsing/parser.mly"
+# 2285 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 35204 "parsing/parser.ml"
+# 35924 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in
let _1 =
let _1 =
-# 3270 "parsing/parser.mly"
+# 3320 "parsing/parser.mly"
( Ptyp_package (package_type_of_module_type _1) )
-# 35282 "parsing/parser.ml"
+# 36002 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 35290 "parsing/parser.ml"
+# 36010 "parsing/parser.ml"
in
-# 3271 "parsing/parser.mly"
+# 3321 "parsing/parser.mly"
( _1 )
-# 35296 "parsing/parser.ml"
+# 36016 "parsing/parser.ml"
in
let _3 =
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 35306 "parsing/parser.ml"
+# 36026 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 35312 "parsing/parser.ml"
+# 36032 "parsing/parser.ml"
in
let _endpos = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2252 "parsing/parser.mly"
+# 2302 "parsing/parser.mly"
( Pexp_constraint (ghexp ~loc:_sloc (Pexp_pack _4), _6), _3 )
-# 35321 "parsing/parser.ml"
+# 36041 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2235 "parsing/parser.mly"
+# 2285 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 35332 "parsing/parser.ml"
+# 36052 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 35404 "parsing/parser.ml"
+# 36124 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 35410 "parsing/parser.ml"
+# 36130 "parsing/parser.ml"
in
let _loc__6_ = (_startpos__6_, _endpos__6_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2254 "parsing/parser.mly"
+# 2304 "parsing/parser.mly"
( unclosed "(" _loc__1_ ")" _loc__6_ )
-# 35418 "parsing/parser.ml"
+# 36138 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__6_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2235 "parsing/parser.mly"
+# 2285 "parsing/parser.mly"
( let desc, attrs = _1 in
mkexp_attrs ~loc:_sloc desc attrs )
-# 35429 "parsing/parser.ml"
+# 36149 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 35460 "parsing/parser.ml"
+# 36180 "parsing/parser.ml"
in
-# 2258 "parsing/parser.mly"
+# 2308 "parsing/parser.mly"
( Pexp_ident (_1) )
-# 35466 "parsing/parser.ml"
+# 36186 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 35475 "parsing/parser.ml"
+# 36195 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 35481 "parsing/parser.ml"
+# 36201 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.expression) = let _1 =
let _1 =
-# 2260 "parsing/parser.mly"
+# 2310 "parsing/parser.mly"
( Pexp_constant _1 )
-# 35507 "parsing/parser.ml"
+# 36227 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 35515 "parsing/parser.ml"
+# 36235 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 35521 "parsing/parser.ml"
+# 36241 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 35552 "parsing/parser.ml"
+# 36272 "parsing/parser.ml"
in
-# 2262 "parsing/parser.mly"
+# 2312 "parsing/parser.mly"
( Pexp_construct(_1, None) )
-# 35558 "parsing/parser.ml"
+# 36278 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 35567 "parsing/parser.ml"
+# 36287 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 35573 "parsing/parser.ml"
+# 36293 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.expression) = let _1 =
let _1 =
-# 2264 "parsing/parser.mly"
+# 2314 "parsing/parser.mly"
( Pexp_variant(_1, None) )
-# 35599 "parsing/parser.ml"
+# 36319 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 35607 "parsing/parser.ml"
+# 36327 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 35613 "parsing/parser.ml"
+# 36333 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : (Parsetree.expression) = Obj.magic _2 in
let _1 : (
-# 666 "parsing/parser.mly"
+# 671 "parsing/parser.mly"
(string)
-# 35641 "parsing/parser.ml"
+# 36361 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 35655 "parsing/parser.ml"
+# 36375 "parsing/parser.ml"
in
-# 2266 "parsing/parser.mly"
+# 2316 "parsing/parser.mly"
( Pexp_apply(_1, [Nolabel,_2]) )
-# 35661 "parsing/parser.ml"
+# 36381 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 35671 "parsing/parser.ml"
+# 36391 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 35677 "parsing/parser.ml"
+# 36397 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _1 =
let _1 =
-# 2267 "parsing/parser.mly"
+# 2317 "parsing/parser.mly"
("!")
-# 35712 "parsing/parser.ml"
+# 36432 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 35720 "parsing/parser.ml"
+# 36440 "parsing/parser.ml"
in
-# 2268 "parsing/parser.mly"
+# 2318 "parsing/parser.mly"
( Pexp_apply(_1, [Nolabel,_2]) )
-# 35726 "parsing/parser.ml"
+# 36446 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 35736 "parsing/parser.ml"
+# 36456 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 35742 "parsing/parser.ml"
+# 36462 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression) = let _1 =
let _1 =
let _2 =
-# 2519 "parsing/parser.mly"
+# 2569 "parsing/parser.mly"
( xs )
-# 35783 "parsing/parser.ml"
+# 36503 "parsing/parser.ml"
in
-# 2270 "parsing/parser.mly"
+# 2320 "parsing/parser.mly"
( Pexp_override _2 )
-# 35788 "parsing/parser.ml"
+# 36508 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 35798 "parsing/parser.ml"
+# 36518 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 35804 "parsing/parser.ml"
+# 36524 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression) = let _1 =
let _1 =
let _2 =
-# 2519 "parsing/parser.mly"
+# 2569 "parsing/parser.mly"
( xs )
-# 35845 "parsing/parser.ml"
+# 36565 "parsing/parser.ml"
in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2272 "parsing/parser.mly"
+# 2322 "parsing/parser.mly"
( unclosed "{<" _loc__1_ ">}" _loc__3_ )
-# 35852 "parsing/parser.ml"
+# 36572 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 35862 "parsing/parser.ml"
+# 36582 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 35868 "parsing/parser.ml"
+# 36588 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__2_ in
let _v : (Parsetree.expression) = let _1 =
let _1 =
-# 2274 "parsing/parser.mly"
+# 2324 "parsing/parser.mly"
( Pexp_override [] )
-# 35901 "parsing/parser.ml"
+# 36621 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 35910 "parsing/parser.ml"
+# 36630 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 35916 "parsing/parser.ml"
+# 36636 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 35962 "parsing/parser.ml"
+# 36682 "parsing/parser.ml"
in
-# 2276 "parsing/parser.mly"
+# 2326 "parsing/parser.mly"
( Pexp_field(_1, _3) )
-# 35968 "parsing/parser.ml"
+# 36688 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 35978 "parsing/parser.ml"
+# 36698 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 35984 "parsing/parser.ml"
+# 36704 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 36044 "parsing/parser.ml"
+# 36764 "parsing/parser.ml"
in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1443 "parsing/parser.mly"
+# 1493 "parsing/parser.mly"
( let loc = make_loc _loc__1_ in
let me = Mod.ident ~loc _1 in
Opn.mk ~loc me )
-# 36053 "parsing/parser.ml"
+# 36773 "parsing/parser.ml"
in
-# 2278 "parsing/parser.mly"
+# 2328 "parsing/parser.mly"
( Pexp_open(od, _4) )
-# 36059 "parsing/parser.ml"
+# 36779 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 36069 "parsing/parser.ml"
+# 36789 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 36075 "parsing/parser.ml"
+# 36795 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression) = let _1 =
let _1 =
let _4 =
-# 2519 "parsing/parser.mly"
+# 2569 "parsing/parser.mly"
( xs )
-# 36130 "parsing/parser.ml"
+# 36850 "parsing/parser.ml"
in
let od =
let _1 =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 36140 "parsing/parser.ml"
+# 36860 "parsing/parser.ml"
in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1443 "parsing/parser.mly"
+# 1493 "parsing/parser.mly"
( let loc = make_loc _loc__1_ in
let me = Mod.ident ~loc _1 in
Opn.mk ~loc me )
-# 36149 "parsing/parser.ml"
+# 36869 "parsing/parser.ml"
in
let _startpos_od_ = _startpos__1_ in
let _symbolstartpos = _startpos_od_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2280 "parsing/parser.mly"
+# 2330 "parsing/parser.mly"
( (* TODO: review the location of Pexp_override *)
Pexp_open(od, mkexp ~loc:_sloc (Pexp_override _4)) )
-# 36160 "parsing/parser.ml"
+# 36880 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 36170 "parsing/parser.ml"
+# 36890 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 36176 "parsing/parser.ml"
+# 36896 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression) = let _1 =
let _1 =
let _4 =
-# 2519 "parsing/parser.mly"
+# 2569 "parsing/parser.mly"
( xs )
-# 36231 "parsing/parser.ml"
+# 36951 "parsing/parser.ml"
in
let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2283 "parsing/parser.mly"
+# 2333 "parsing/parser.mly"
( unclosed "{<" _loc__3_ ">}" _loc__5_ )
-# 36238 "parsing/parser.ml"
+# 36958 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 36248 "parsing/parser.ml"
+# 36968 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 36254 "parsing/parser.ml"
+# 36974 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _1_inlined1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 36287 "parsing/parser.ml"
+# 37007 "parsing/parser.ml"
) = Obj.magic _1_inlined1 in
let _2 : unit = Obj.magic _2 in
let _1 : (Parsetree.expression) = Obj.magic _1 in
let _3 =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 36301 "parsing/parser.ml"
+# 37021 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 36309 "parsing/parser.ml"
+# 37029 "parsing/parser.ml"
in
-# 2285 "parsing/parser.mly"
+# 2335 "parsing/parser.mly"
( Pexp_send(_1, _3) )
-# 36315 "parsing/parser.ml"
+# 37035 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 36325 "parsing/parser.ml"
+# 37045 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 36331 "parsing/parser.ml"
+# 37051 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : (Parsetree.expression) = Obj.magic _3 in
let _1_inlined1 : (
-# 677 "parsing/parser.mly"
+# 682 "parsing/parser.mly"
(string)
-# 36365 "parsing/parser.ml"
+# 37085 "parsing/parser.ml"
) = Obj.magic _1_inlined1 in
let _1 : (Parsetree.expression) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 819 "parsing/parser.mly"
+# 840 "parsing/parser.mly"
( mkoperator ~loc:_sloc _1 )
-# 36381 "parsing/parser.ml"
+# 37101 "parsing/parser.ml"
in
-# 2287 "parsing/parser.mly"
+# 2337 "parsing/parser.mly"
( mkinfix _1 _2 _3 )
-# 36387 "parsing/parser.ml"
+# 37107 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 36397 "parsing/parser.ml"
+# 37117 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 36403 "parsing/parser.ml"
+# 37123 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.expression) = let _1 =
let _1 =
-# 2289 "parsing/parser.mly"
+# 2339 "parsing/parser.mly"
( Pexp_extension _1 )
-# 36429 "parsing/parser.ml"
+# 37149 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 36437 "parsing/parser.ml"
+# 37157 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 36443 "parsing/parser.ml"
+# 37163 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 =
let (_endpos__2_, _startpos__1_, _2, _1) = (_endpos__2_inlined1_, _startpos__1_inlined1_, _2_inlined1, _1_inlined1) in
let _1 =
-# 2290 "parsing/parser.mly"
+# 2340 "parsing/parser.mly"
(Lident "()")
-# 36493 "parsing/parser.ml"
+# 37213 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 36502 "parsing/parser.ml"
+# 37222 "parsing/parser.ml"
in
let _endpos__3_ = _endpos__2_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 36514 "parsing/parser.ml"
+# 37234 "parsing/parser.ml"
in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1443 "parsing/parser.mly"
+# 1493 "parsing/parser.mly"
( let loc = make_loc _loc__1_ in
let me = Mod.ident ~loc _1 in
Opn.mk ~loc me )
-# 36523 "parsing/parser.ml"
+# 37243 "parsing/parser.ml"
in
let _startpos_od_ = _startpos__1_ in
let _symbolstartpos = _startpos_od_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2291 "parsing/parser.mly"
+# 2341 "parsing/parser.mly"
( (* TODO: review the location of Pexp_construct *)
Pexp_open(od, mkexp ~loc:_sloc (Pexp_construct(_3, None))) )
-# 36534 "parsing/parser.ml"
+# 37254 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 36544 "parsing/parser.ml"
+# 37264 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 36550 "parsing/parser.ml"
+# 37270 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2294 "parsing/parser.mly"
+# 2344 "parsing/parser.mly"
( unclosed "(" _loc__3_ ")" _loc__5_ )
-# 36607 "parsing/parser.ml"
+# 37327 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 36617 "parsing/parser.ml"
+# 37337 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 36623 "parsing/parser.ml"
+# 37343 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__3_ in
let _v : (Parsetree.expression) = let _1 =
let _1 =
-# 2296 "parsing/parser.mly"
+# 2346 "parsing/parser.mly"
( let (exten, fields) = _2 in
Pexp_record(fields, exten) )
-# 36665 "parsing/parser.ml"
+# 37385 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 36674 "parsing/parser.ml"
+# 37394 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 36680 "parsing/parser.ml"
+# 37400 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _loc__3_ = (_startpos__3_, _endpos__3_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2299 "parsing/parser.mly"
+# 2349 "parsing/parser.mly"
( unclosed "{" _loc__1_ "}" _loc__3_ )
-# 36724 "parsing/parser.ml"
+# 37444 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 36734 "parsing/parser.ml"
+# 37454 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 36740 "parsing/parser.ml"
+# 37460 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 36801 "parsing/parser.ml"
+# 37521 "parsing/parser.ml"
in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1443 "parsing/parser.mly"
+# 1493 "parsing/parser.mly"
( let loc = make_loc _loc__1_ in
let me = Mod.ident ~loc _1 in
Opn.mk ~loc me )
-# 36810 "parsing/parser.ml"
+# 37530 "parsing/parser.ml"
in
let _startpos_od_ = _startpos__1_ in
let _symbolstartpos = _startpos_od_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2301 "parsing/parser.mly"
+# 2351 "parsing/parser.mly"
( let (exten, fields) = _4 in
(* TODO: review the location of Pexp_construct *)
Pexp_open(od, mkexp ~loc:_sloc (Pexp_record(fields, exten))) )
-# 36822 "parsing/parser.ml"
+# 37542 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 36832 "parsing/parser.ml"
+# 37552 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 36838 "parsing/parser.ml"
+# 37558 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2305 "parsing/parser.mly"
+# 2355 "parsing/parser.mly"
( unclosed "{" _loc__3_ "}" _loc__5_ )
-# 36896 "parsing/parser.ml"
+# 37616 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 36906 "parsing/parser.ml"
+# 37626 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 36912 "parsing/parser.ml"
+# 37632 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression) = let _1 =
let _1 =
let _2 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 36953 "parsing/parser.ml"
+# 37673 "parsing/parser.ml"
in
-# 2307 "parsing/parser.mly"
+# 2357 "parsing/parser.mly"
( Pexp_array(_2) )
-# 36958 "parsing/parser.ml"
+# 37678 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 36968 "parsing/parser.ml"
+# 37688 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 36974 "parsing/parser.ml"
+# 37694 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression) = let _1 =
let _1 =
let _2 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 37015 "parsing/parser.ml"
+# 37735 "parsing/parser.ml"
in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2309 "parsing/parser.mly"
+# 2359 "parsing/parser.mly"
( unclosed "[|" _loc__1_ "|]" _loc__3_ )
-# 37022 "parsing/parser.ml"
+# 37742 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 37032 "parsing/parser.ml"
+# 37752 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 37038 "parsing/parser.ml"
+# 37758 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__2_ in
let _v : (Parsetree.expression) = let _1 =
let _1 =
-# 2311 "parsing/parser.mly"
+# 2361 "parsing/parser.mly"
( Pexp_array [] )
-# 37071 "parsing/parser.ml"
+# 37791 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 37080 "parsing/parser.ml"
+# 37800 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 37086 "parsing/parser.ml"
+# 37806 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression) = let _1 =
let _1 =
let _4 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 37141 "parsing/parser.ml"
+# 37861 "parsing/parser.ml"
in
let od =
let _1 =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 37151 "parsing/parser.ml"
+# 37871 "parsing/parser.ml"
in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1443 "parsing/parser.mly"
+# 1493 "parsing/parser.mly"
( let loc = make_loc _loc__1_ in
let me = Mod.ident ~loc _1 in
Opn.mk ~loc me )
-# 37160 "parsing/parser.ml"
+# 37880 "parsing/parser.ml"
in
let _startpos_od_ = _startpos__1_ in
let _symbolstartpos = _startpos_od_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2313 "parsing/parser.mly"
+# 2363 "parsing/parser.mly"
( (* TODO: review the location of Pexp_array *)
Pexp_open(od, mkexp ~loc:_sloc (Pexp_array(_4))) )
-# 37171 "parsing/parser.ml"
+# 37891 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 37181 "parsing/parser.ml"
+# 37901 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 37187 "parsing/parser.ml"
+# 37907 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 37240 "parsing/parser.ml"
+# 37960 "parsing/parser.ml"
in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1443 "parsing/parser.mly"
+# 1493 "parsing/parser.mly"
( let loc = make_loc _loc__1_ in
let me = Mod.ident ~loc _1 in
Opn.mk ~loc me )
-# 37249 "parsing/parser.ml"
+# 37969 "parsing/parser.ml"
in
let _startpos_od_ = _startpos__1_ in
let _symbolstartpos = _startpos_od_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2316 "parsing/parser.mly"
+# 2366 "parsing/parser.mly"
( (* TODO: review the location of Pexp_array *)
Pexp_open(od, mkexp ~loc:_sloc (Pexp_array [])) )
-# 37260 "parsing/parser.ml"
+# 37980 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 37270 "parsing/parser.ml"
+# 37990 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 37276 "parsing/parser.ml"
+# 37996 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression) = let _1 =
let _1 =
let _4 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 37331 "parsing/parser.ml"
+# 38051 "parsing/parser.ml"
in
let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2320 "parsing/parser.mly"
+# 2370 "parsing/parser.mly"
( unclosed "[|" _loc__3_ "|]" _loc__5_ )
-# 37338 "parsing/parser.ml"
+# 38058 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 37348 "parsing/parser.ml"
+# 38068 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 37354 "parsing/parser.ml"
+# 38074 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression) = let _1 =
let _1 =
let _2 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 37395 "parsing/parser.ml"
+# 38115 "parsing/parser.ml"
in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2322 "parsing/parser.mly"
+# 2372 "parsing/parser.mly"
( fst (mktailexp _loc__3_ _2) )
-# 37401 "parsing/parser.ml"
+# 38121 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 37411 "parsing/parser.ml"
+# 38131 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 37417 "parsing/parser.ml"
+# 38137 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression) = let _1 =
let _1 =
let _2 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 37458 "parsing/parser.ml"
+# 38178 "parsing/parser.ml"
in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2324 "parsing/parser.mly"
+# 2374 "parsing/parser.mly"
( unclosed "[" _loc__1_ "]" _loc__3_ )
-# 37465 "parsing/parser.ml"
+# 38185 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 37475 "parsing/parser.ml"
+# 38195 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 37481 "parsing/parser.ml"
+# 38201 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression) = let _1 =
let _1 =
let _4 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 37536 "parsing/parser.ml"
+# 38256 "parsing/parser.ml"
in
let od =
let _1 =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 37546 "parsing/parser.ml"
+# 38266 "parsing/parser.ml"
in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1443 "parsing/parser.mly"
+# 1493 "parsing/parser.mly"
( let loc = make_loc _loc__1_ in
let me = Mod.ident ~loc _1 in
Opn.mk ~loc me )
-# 37555 "parsing/parser.ml"
+# 38275 "parsing/parser.ml"
in
let _startpos_od_ = _startpos__1_ in
let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _sloc = (_symbolstartpos, _endpos) in
-# 2326 "parsing/parser.mly"
+# 2376 "parsing/parser.mly"
( let list_exp =
(* TODO: review the location of list_exp *)
let tail_exp, _tail_loc = mktailexp _loc__5_ _4 in
mkexp ~loc:_sloc tail_exp in
Pexp_open(od, list_exp) )
-# 37570 "parsing/parser.ml"
+# 38290 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 37580 "parsing/parser.ml"
+# 38300 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 37586 "parsing/parser.ml"
+# 38306 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 =
let (_endpos__2_, _startpos__1_, _2, _1) = (_endpos__2_inlined1_, _startpos__1_inlined1_, _2_inlined1, _1_inlined1) in
let _1 =
-# 2331 "parsing/parser.mly"
+# 2381 "parsing/parser.mly"
(Lident "[]")
-# 37636 "parsing/parser.ml"
+# 38356 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 37645 "parsing/parser.ml"
+# 38365 "parsing/parser.ml"
in
let _endpos__3_ = _endpos__2_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 37657 "parsing/parser.ml"
+# 38377 "parsing/parser.ml"
in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1443 "parsing/parser.mly"
+# 1493 "parsing/parser.mly"
( let loc = make_loc _loc__1_ in
let me = Mod.ident ~loc _1 in
Opn.mk ~loc me )
-# 37666 "parsing/parser.ml"
+# 38386 "parsing/parser.ml"
in
let _startpos_od_ = _startpos__1_ in
let _symbolstartpos = _startpos_od_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2332 "parsing/parser.mly"
+# 2382 "parsing/parser.mly"
( (* TODO: review the location of Pexp_construct *)
Pexp_open(od, mkexp ~loc:_sloc (Pexp_construct(_3, None))) )
-# 37677 "parsing/parser.ml"
+# 38397 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 37687 "parsing/parser.ml"
+# 38407 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 37693 "parsing/parser.ml"
+# 38413 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.expression) = let _1 =
let _1 =
let _4 =
-# 2536 "parsing/parser.mly"
+# 2586 "parsing/parser.mly"
( es )
-# 37748 "parsing/parser.ml"
+# 38468 "parsing/parser.ml"
in
let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2336 "parsing/parser.mly"
+# 2386 "parsing/parser.mly"
( unclosed "[" _loc__3_ "]" _loc__5_ )
-# 37755 "parsing/parser.ml"
+# 38475 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 37765 "parsing/parser.ml"
+# 38485 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 37771 "parsing/parser.ml"
+# 38491 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in
let _1 =
let _1 =
-# 3270 "parsing/parser.mly"
+# 3320 "parsing/parser.mly"
( Ptyp_package (package_type_of_module_type _1) )
-# 37864 "parsing/parser.ml"
+# 38584 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 37872 "parsing/parser.ml"
+# 38592 "parsing/parser.ml"
in
-# 3271 "parsing/parser.mly"
+# 3321 "parsing/parser.mly"
( _1 )
-# 37878 "parsing/parser.ml"
+# 38598 "parsing/parser.ml"
in
let _5 =
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 37888 "parsing/parser.ml"
+# 38608 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 37894 "parsing/parser.ml"
+# 38614 "parsing/parser.ml"
in
let od =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 37905 "parsing/parser.ml"
+# 38625 "parsing/parser.ml"
in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 1443 "parsing/parser.mly"
+# 1493 "parsing/parser.mly"
( let loc = make_loc _loc__1_ in
let me = Mod.ident ~loc _1 in
Opn.mk ~loc me )
-# 37914 "parsing/parser.ml"
+# 38634 "parsing/parser.ml"
in
let _startpos_od_ = _startpos__1_ in
let _symbolstartpos = _startpos_od_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2339 "parsing/parser.mly"
+# 2389 "parsing/parser.mly"
( (* TODO: review the location of Pexp_constraint *)
let modexp =
mkexp_attrs ~loc:_sloc
(Pexp_constraint (ghexp ~loc:_sloc (Pexp_pack _6), _8)) _5 in
Pexp_open(od, modexp) )
-# 37928 "parsing/parser.ml"
+# 38648 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__9_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 37938 "parsing/parser.ml"
+# 38658 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 37944 "parsing/parser.ml"
+# 38664 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 38031 "parsing/parser.ml"
+# 38751 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 38037 "parsing/parser.ml"
+# 38757 "parsing/parser.ml"
in
let _loc__8_ = (_startpos__8_, _endpos__8_) in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2346 "parsing/parser.mly"
+# 2396 "parsing/parser.mly"
( unclosed "(" _loc__3_ ")" _loc__8_ )
-# 38045 "parsing/parser.ml"
+# 38765 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__8_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 825 "parsing/parser.mly"
+# 846 "parsing/parser.mly"
( mkexp ~loc:_sloc _1 )
-# 38055 "parsing/parser.ml"
+# 38775 "parsing/parser.ml"
in
-# 2238 "parsing/parser.mly"
+# 2288 "parsing/parser.mly"
( _1 )
-# 38061 "parsing/parser.ml"
+# 38781 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.endp = _endpos__1_;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
- let _1 : (string) = Obj.magic _1 in
+ let _1 : (Asttypes.label) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 38092 "parsing/parser.ml"
+# 38812 "parsing/parser.ml"
in
-# 2616 "parsing/parser.mly"
+# 2666 "parsing/parser.mly"
( Ppat_var (_1) )
-# 38098 "parsing/parser.ml"
+# 38818 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 38107 "parsing/parser.ml"
+# 38827 "parsing/parser.ml"
in
-# 2617 "parsing/parser.mly"
+# 2667 "parsing/parser.mly"
( _1 )
-# 38113 "parsing/parser.ml"
+# 38833 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.pattern) =
-# 2618 "parsing/parser.mly"
+# 2668 "parsing/parser.mly"
( _1 )
-# 38138 "parsing/parser.ml"
+# 38858 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2623 "parsing/parser.mly"
+# 2673 "parsing/parser.mly"
( reloc_pat ~loc:_sloc _2 )
-# 38180 "parsing/parser.ml"
+# 38900 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.pattern) =
-# 2625 "parsing/parser.mly"
+# 2675 "parsing/parser.mly"
( _1 )
-# 38205 "parsing/parser.ml"
+# 38925 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 38270 "parsing/parser.ml"
+# 38990 "parsing/parser.ml"
in
let _3 =
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 38280 "parsing/parser.ml"
+# 39000 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 38286 "parsing/parser.ml"
+# 39006 "parsing/parser.ml"
in
let _endpos = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2627 "parsing/parser.mly"
+# 2677 "parsing/parser.mly"
( mkpat_attrs ~loc:_sloc (Ppat_unpack _4) _3 )
-# 38295 "parsing/parser.ml"
+# 39015 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined4_, _startpos__1_inlined4_, _1_inlined4) in
let _1 =
let _1 =
-# 3270 "parsing/parser.mly"
+# 3320 "parsing/parser.mly"
( Ptyp_package (package_type_of_module_type _1) )
-# 38372 "parsing/parser.ml"
+# 39092 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 38380 "parsing/parser.ml"
+# 39100 "parsing/parser.ml"
in
-# 3271 "parsing/parser.mly"
+# 3321 "parsing/parser.mly"
( _1 )
-# 38386 "parsing/parser.ml"
+# 39106 "parsing/parser.ml"
in
let _4 =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 38397 "parsing/parser.ml"
+# 39117 "parsing/parser.ml"
in
let _3 =
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 38407 "parsing/parser.ml"
+# 39127 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 38413 "parsing/parser.ml"
+# 39133 "parsing/parser.ml"
in
let _endpos = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2629 "parsing/parser.mly"
+# 2679 "parsing/parser.mly"
( mkpat_attrs ~loc:_sloc
(Ppat_constraint(mkpat ~loc:_sloc (Ppat_unpack _4), _6))
_3 )
-# 38424 "parsing/parser.ml"
+# 39144 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.pattern) = let _1 =
let _1 =
-# 2637 "parsing/parser.mly"
+# 2687 "parsing/parser.mly"
( Ppat_any )
-# 38450 "parsing/parser.ml"
+# 39170 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 38458 "parsing/parser.ml"
+# 39178 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 38464 "parsing/parser.ml"
+# 39184 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.pattern) = let _1 =
let _1 =
-# 2639 "parsing/parser.mly"
+# 2689 "parsing/parser.mly"
( Ppat_constant _1 )
-# 38490 "parsing/parser.ml"
+# 39210 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 38498 "parsing/parser.ml"
+# 39218 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 38504 "parsing/parser.ml"
+# 39224 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__3_ in
let _v : (Parsetree.pattern) = let _1 =
let _1 =
-# 2641 "parsing/parser.mly"
+# 2691 "parsing/parser.mly"
( Ppat_interval (_1, _3) )
-# 38544 "parsing/parser.ml"
+# 39264 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 38553 "parsing/parser.ml"
+# 39273 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 38559 "parsing/parser.ml"
+# 39279 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 38590 "parsing/parser.ml"
+# 39310 "parsing/parser.ml"
in
-# 2643 "parsing/parser.mly"
+# 2693 "parsing/parser.mly"
( Ppat_construct(_1, None) )
-# 38596 "parsing/parser.ml"
+# 39316 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 38605 "parsing/parser.ml"
+# 39325 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 38611 "parsing/parser.ml"
+# 39331 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.pattern) = let _1 =
let _1 =
-# 2645 "parsing/parser.mly"
+# 2695 "parsing/parser.mly"
( Ppat_variant(_1, None) )
-# 38637 "parsing/parser.ml"
+# 39357 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 38645 "parsing/parser.ml"
+# 39365 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 38651 "parsing/parser.ml"
+# 39371 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 38690 "parsing/parser.ml"
+# 39410 "parsing/parser.ml"
in
-# 2647 "parsing/parser.mly"
+# 2697 "parsing/parser.mly"
( Ppat_type (_2) )
-# 38696 "parsing/parser.ml"
+# 39416 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 38706 "parsing/parser.ml"
+# 39426 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 38712 "parsing/parser.ml"
+# 39432 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 38757 "parsing/parser.ml"
+# 39477 "parsing/parser.ml"
in
-# 2649 "parsing/parser.mly"
+# 2699 "parsing/parser.mly"
( Ppat_open(_1, _3) )
-# 38763 "parsing/parser.ml"
+# 39483 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 38773 "parsing/parser.ml"
+# 39493 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 38779 "parsing/parser.ml"
+# 39499 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 =
let (_endpos__2_, _startpos__1_, _2, _1) = (_endpos__2_inlined1_, _startpos__1_inlined1_, _2_inlined1, _1_inlined1) in
let _1 =
-# 2650 "parsing/parser.mly"
+# 2700 "parsing/parser.mly"
(Lident "[]")
-# 38829 "parsing/parser.ml"
+# 39549 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 38838 "parsing/parser.ml"
+# 39558 "parsing/parser.ml"
in
let _endpos__3_ = _endpos__2_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 38849 "parsing/parser.ml"
+# 39569 "parsing/parser.ml"
in
let _endpos = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2651 "parsing/parser.mly"
+# 2701 "parsing/parser.mly"
( Ppat_open(_1, mkpat ~loc:_sloc (Ppat_construct(_3, None))) )
-# 38858 "parsing/parser.ml"
+# 39578 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 38868 "parsing/parser.ml"
+# 39588 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 38874 "parsing/parser.ml"
+# 39594 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _3 =
let (_endpos__2_, _startpos__1_, _2, _1) = (_endpos__2_inlined1_, _startpos__1_inlined1_, _2_inlined1, _1_inlined1) in
let _1 =
-# 2652 "parsing/parser.mly"
+# 2702 "parsing/parser.mly"
(Lident "()")
-# 38924 "parsing/parser.ml"
+# 39644 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 38933 "parsing/parser.ml"
+# 39653 "parsing/parser.ml"
in
let _endpos__3_ = _endpos__2_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 38944 "parsing/parser.ml"
+# 39664 "parsing/parser.ml"
in
let _endpos = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2653 "parsing/parser.mly"
+# 2703 "parsing/parser.mly"
( Ppat_open(_1, mkpat ~loc:_sloc (Ppat_construct(_3, None))) )
-# 38953 "parsing/parser.ml"
+# 39673 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__2_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 38963 "parsing/parser.ml"
+# 39683 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 38969 "parsing/parser.ml"
+# 39689 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 39028 "parsing/parser.ml"
+# 39748 "parsing/parser.ml"
in
-# 2655 "parsing/parser.mly"
+# 2705 "parsing/parser.mly"
( Ppat_open (_1, _4) )
-# 39034 "parsing/parser.ml"
+# 39754 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 39044 "parsing/parser.ml"
+# 39764 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 39050 "parsing/parser.ml"
+# 39770 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 2657 "parsing/parser.mly"
+# 2707 "parsing/parser.mly"
( unclosed "(" _loc__3_ ")" _loc__5_ )
-# 39107 "parsing/parser.ml"
+# 39827 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 39117 "parsing/parser.ml"
+# 39837 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 39123 "parsing/parser.ml"
+# 39843 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _loc__4_ = (_startpos__4_, _endpos__4_) in
-# 2659 "parsing/parser.mly"
+# 2709 "parsing/parser.mly"
( expecting _loc__4_ "pattern" )
-# 39172 "parsing/parser.ml"
+# 39892 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 39182 "parsing/parser.ml"
+# 39902 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 39188 "parsing/parser.ml"
+# 39908 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _loc__3_ = (_startpos__3_, _endpos__3_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2661 "parsing/parser.mly"
+# 2711 "parsing/parser.mly"
( unclosed "(" _loc__1_ ")" _loc__3_ )
-# 39231 "parsing/parser.ml"
+# 39951 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 39241 "parsing/parser.ml"
+# 39961 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 39247 "parsing/parser.ml"
+# 39967 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : (Parsetree.pattern) = let _1 =
let _1 =
-# 2663 "parsing/parser.mly"
+# 2713 "parsing/parser.mly"
( Ppat_constraint(_2, _4) )
-# 39301 "parsing/parser.ml"
+# 40021 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 39310 "parsing/parser.ml"
+# 40030 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 39316 "parsing/parser.ml"
+# 40036 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _loc__5_ = (_startpos__5_, _endpos__5_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2665 "parsing/parser.mly"
+# 2715 "parsing/parser.mly"
( unclosed "(" _loc__1_ ")" _loc__5_ )
-# 39373 "parsing/parser.ml"
+# 40093 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 39383 "parsing/parser.ml"
+# 40103 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 39389 "parsing/parser.ml"
+# 40109 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _loc__4_ = (_startpos__4_, _endpos__4_) in
-# 2667 "parsing/parser.mly"
+# 2717 "parsing/parser.mly"
( expecting _loc__4_ "type" )
-# 39438 "parsing/parser.ml"
+# 40158 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 39448 "parsing/parser.ml"
+# 40168 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 39454 "parsing/parser.ml"
+# 40174 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in
let _1 =
let _1 =
-# 3270 "parsing/parser.mly"
+# 3320 "parsing/parser.mly"
( Ptyp_package (package_type_of_module_type _1) )
-# 39533 "parsing/parser.ml"
+# 40253 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 39541 "parsing/parser.ml"
+# 40261 "parsing/parser.ml"
in
-# 3271 "parsing/parser.mly"
+# 3321 "parsing/parser.mly"
( _1 )
-# 39547 "parsing/parser.ml"
+# 40267 "parsing/parser.ml"
in
let _3 =
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 39557 "parsing/parser.ml"
+# 40277 "parsing/parser.ml"
in
-# 3680 "parsing/parser.mly"
+# 3742 "parsing/parser.mly"
( _1, _2 )
-# 39563 "parsing/parser.ml"
+# 40283 "parsing/parser.ml"
in
let _loc__7_ = (_startpos__7_, _endpos__7_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 2670 "parsing/parser.mly"
+# 2720 "parsing/parser.mly"
( unclosed "(" _loc__1_ ")" _loc__7_ )
-# 39571 "parsing/parser.ml"
+# 40291 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__7_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 39581 "parsing/parser.ml"
+# 40301 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 39587 "parsing/parser.ml"
+# 40307 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.pattern) = let _1 =
let _1 =
-# 2672 "parsing/parser.mly"
+# 2722 "parsing/parser.mly"
( Ppat_extension _1 )
-# 39613 "parsing/parser.ml"
+# 40333 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 827 "parsing/parser.mly"
+# 848 "parsing/parser.mly"
( mkpat ~loc:_sloc _1 )
-# 39621 "parsing/parser.ml"
+# 40341 "parsing/parser.ml"
in
-# 2633 "parsing/parser.mly"
+# 2683 "parsing/parser.mly"
( _1 )
-# 39627 "parsing/parser.ml"
+# 40347 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 39648 "parsing/parser.ml"
+# 40368 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3590 "parsing/parser.mly"
+# 3652 "parsing/parser.mly"
( _1 )
-# 39656 "parsing/parser.ml"
+# 40376 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 688 "parsing/parser.mly"
+# 697 "parsing/parser.mly"
(string)
-# 39677 "parsing/parser.ml"
+# 40397 "parsing/parser.ml"
) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3591 "parsing/parser.mly"
+# 3653 "parsing/parser.mly"
( _1 )
-# 39685 "parsing/parser.ml"
+# 40405 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3592 "parsing/parser.mly"
+# 3654 "parsing/parser.mly"
( "and" )
-# 39710 "parsing/parser.ml"
+# 40430 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3593 "parsing/parser.mly"
+# 3655 "parsing/parser.mly"
( "as" )
-# 39735 "parsing/parser.ml"
+# 40455 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3594 "parsing/parser.mly"
+# 3656 "parsing/parser.mly"
( "assert" )
-# 39760 "parsing/parser.ml"
+# 40480 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3595 "parsing/parser.mly"
+# 3657 "parsing/parser.mly"
( "begin" )
-# 39785 "parsing/parser.ml"
+# 40505 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3596 "parsing/parser.mly"
+# 3658 "parsing/parser.mly"
( "class" )
-# 39810 "parsing/parser.ml"
+# 40530 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3597 "parsing/parser.mly"
+# 3659 "parsing/parser.mly"
( "constraint" )
-# 39835 "parsing/parser.ml"
+# 40555 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3598 "parsing/parser.mly"
+# 3660 "parsing/parser.mly"
( "do" )
-# 39860 "parsing/parser.ml"
+# 40580 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3599 "parsing/parser.mly"
+# 3661 "parsing/parser.mly"
( "done" )
-# 39885 "parsing/parser.ml"
+# 40605 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3600 "parsing/parser.mly"
+# 3662 "parsing/parser.mly"
( "downto" )
-# 39910 "parsing/parser.ml"
+# 40630 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3601 "parsing/parser.mly"
+# 3663 "parsing/parser.mly"
( "else" )
-# 39935 "parsing/parser.ml"
+# 40655 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3602 "parsing/parser.mly"
+# 3664 "parsing/parser.mly"
( "end" )
-# 39960 "parsing/parser.ml"
+# 40680 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3603 "parsing/parser.mly"
+# 3665 "parsing/parser.mly"
( "exception" )
-# 39985 "parsing/parser.ml"
+# 40705 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3604 "parsing/parser.mly"
+# 3666 "parsing/parser.mly"
( "external" )
-# 40010 "parsing/parser.ml"
+# 40730 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3605 "parsing/parser.mly"
+# 3667 "parsing/parser.mly"
( "false" )
-# 40035 "parsing/parser.ml"
+# 40755 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3606 "parsing/parser.mly"
+# 3668 "parsing/parser.mly"
( "for" )
-# 40060 "parsing/parser.ml"
+# 40780 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3607 "parsing/parser.mly"
+# 3669 "parsing/parser.mly"
( "fun" )
-# 40085 "parsing/parser.ml"
+# 40805 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3608 "parsing/parser.mly"
+# 3670 "parsing/parser.mly"
( "function" )
-# 40110 "parsing/parser.ml"
+# 40830 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3609 "parsing/parser.mly"
+# 3671 "parsing/parser.mly"
( "functor" )
-# 40135 "parsing/parser.ml"
+# 40855 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3610 "parsing/parser.mly"
+# 3672 "parsing/parser.mly"
( "if" )
-# 40160 "parsing/parser.ml"
+# 40880 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3611 "parsing/parser.mly"
+# 3673 "parsing/parser.mly"
( "in" )
-# 40185 "parsing/parser.ml"
+# 40905 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3612 "parsing/parser.mly"
+# 3674 "parsing/parser.mly"
( "include" )
-# 40210 "parsing/parser.ml"
+# 40930 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3613 "parsing/parser.mly"
+# 3675 "parsing/parser.mly"
( "inherit" )
-# 40235 "parsing/parser.ml"
+# 40955 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3614 "parsing/parser.mly"
+# 3676 "parsing/parser.mly"
( "initializer" )
-# 40260 "parsing/parser.ml"
+# 40980 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3615 "parsing/parser.mly"
+# 3677 "parsing/parser.mly"
( "lazy" )
-# 40285 "parsing/parser.ml"
+# 41005 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3616 "parsing/parser.mly"
+# 3678 "parsing/parser.mly"
( "let" )
-# 40310 "parsing/parser.ml"
+# 41030 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3617 "parsing/parser.mly"
+# 3679 "parsing/parser.mly"
( "match" )
-# 40335 "parsing/parser.ml"
+# 41055 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3618 "parsing/parser.mly"
+# 3680 "parsing/parser.mly"
( "method" )
-# 40360 "parsing/parser.ml"
+# 41080 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3619 "parsing/parser.mly"
+# 3681 "parsing/parser.mly"
( "module" )
-# 40385 "parsing/parser.ml"
+# 41105 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3620 "parsing/parser.mly"
+# 3682 "parsing/parser.mly"
( "mutable" )
-# 40410 "parsing/parser.ml"
+# 41130 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3621 "parsing/parser.mly"
+# 3683 "parsing/parser.mly"
( "new" )
-# 40435 "parsing/parser.ml"
+# 41155 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3622 "parsing/parser.mly"
+# 3684 "parsing/parser.mly"
( "nonrec" )
-# 40460 "parsing/parser.ml"
+# 41180 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3623 "parsing/parser.mly"
+# 3685 "parsing/parser.mly"
( "object" )
-# 40485 "parsing/parser.ml"
+# 41205 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3624 "parsing/parser.mly"
+# 3686 "parsing/parser.mly"
( "of" )
-# 40510 "parsing/parser.ml"
+# 41230 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3625 "parsing/parser.mly"
+# 3687 "parsing/parser.mly"
( "open" )
-# 40535 "parsing/parser.ml"
+# 41255 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3626 "parsing/parser.mly"
+# 3688 "parsing/parser.mly"
( "or" )
-# 40560 "parsing/parser.ml"
+# 41280 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3627 "parsing/parser.mly"
+# 3689 "parsing/parser.mly"
( "private" )
-# 40585 "parsing/parser.ml"
+# 41305 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3628 "parsing/parser.mly"
+# 3690 "parsing/parser.mly"
( "rec" )
-# 40610 "parsing/parser.ml"
+# 41330 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3629 "parsing/parser.mly"
+# 3691 "parsing/parser.mly"
( "sig" )
-# 40635 "parsing/parser.ml"
+# 41355 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3630 "parsing/parser.mly"
+# 3692 "parsing/parser.mly"
( "struct" )
-# 40660 "parsing/parser.ml"
+# 41380 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3631 "parsing/parser.mly"
+# 3693 "parsing/parser.mly"
( "then" )
-# 40685 "parsing/parser.ml"
+# 41405 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3632 "parsing/parser.mly"
+# 3694 "parsing/parser.mly"
( "to" )
-# 40710 "parsing/parser.ml"
+# 41430 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3633 "parsing/parser.mly"
+# 3695 "parsing/parser.mly"
( "true" )
-# 40735 "parsing/parser.ml"
+# 41455 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3634 "parsing/parser.mly"
+# 3696 "parsing/parser.mly"
( "try" )
-# 40760 "parsing/parser.ml"
+# 41480 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3635 "parsing/parser.mly"
+# 3697 "parsing/parser.mly"
( "type" )
-# 40785 "parsing/parser.ml"
+# 41505 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3636 "parsing/parser.mly"
+# 3698 "parsing/parser.mly"
( "val" )
-# 40810 "parsing/parser.ml"
+# 41530 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3637 "parsing/parser.mly"
+# 3699 "parsing/parser.mly"
( "virtual" )
-# 40835 "parsing/parser.ml"
+# 41555 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3638 "parsing/parser.mly"
+# 3700 "parsing/parser.mly"
( "when" )
-# 40860 "parsing/parser.ml"
+# 41580 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3639 "parsing/parser.mly"
+# 3701 "parsing/parser.mly"
( "while" )
-# 40885 "parsing/parser.ml"
+# 41605 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3640 "parsing/parser.mly"
+# 3702 "parsing/parser.mly"
( "with" )
-# 40910 "parsing/parser.ml"
+# 41630 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Parsetree.type_exception * string Asttypes.loc option) =
-# 2937 "parsing/parser.mly"
+# 2987 "parsing/parser.mly"
( _1 )
-# 40935 "parsing/parser.ml"
+# 41655 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in
let _1_inlined3 : (Longident.t) = Obj.magic _1_inlined3 in
let _5 : unit = Obj.magic _5 in
- let _1_inlined2 : (string) = Obj.magic _1_inlined2 in
+ let _1_inlined2 : (Asttypes.label) = Obj.magic _1_inlined2 in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
let ext : (string Asttypes.loc option) = Obj.magic ext in
let _1 : unit = Obj.magic _1 in
let _v : (Parsetree.type_exception * string Asttypes.loc option) = let attrs =
let _1 = _1_inlined5 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 41011 "parsing/parser.ml"
+# 41731 "parsing/parser.ml"
in
let _endpos_attrs_ = _endpos__1_inlined5_ in
let attrs2 =
let _1 = _1_inlined4 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 41020 "parsing/parser.ml"
+# 41740 "parsing/parser.ml"
in
let lid =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 41031 "parsing/parser.ml"
+# 41751 "parsing/parser.ml"
in
let id =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 41042 "parsing/parser.ml"
+# 41762 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 41050 "parsing/parser.ml"
+# 41770 "parsing/parser.ml"
in
let _endpos = _endpos_attrs_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2946 "parsing/parser.mly"
+# 2996 "parsing/parser.mly"
( let loc = make_loc _sloc in
let docs = symbol_docs _sloc in
Te.mk_exception ~attrs
(Te.rebind id lid ~attrs:(attrs1 @ attrs2) ~loc ~docs)
, ext )
-# 41063 "parsing/parser.ml"
+# 41783 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.expression) =
-# 2461 "parsing/parser.mly"
+# 2511 "parsing/parser.mly"
( _2 )
-# 41095 "parsing/parser.ml"
+# 41815 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2463 "parsing/parser.mly"
+# 2513 "parsing/parser.mly"
( let (l, o, p) = _1 in ghexp ~loc:_sloc (Pexp_fun(l, o, p, _2)) )
-# 41130 "parsing/parser.ml"
+# 41850 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : (Parsetree.expression) = let _3 =
-# 2364 "parsing/parser.mly"
+# 2414 "parsing/parser.mly"
( xs )
-# 41183 "parsing/parser.ml"
+# 41903 "parsing/parser.ml"
in
let _endpos = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2465 "parsing/parser.mly"
+# 2515 "parsing/parser.mly"
( mk_newtypes ~loc:_sloc _3 _5 )
-# 41191 "parsing/parser.ml"
+# 41911 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.structure) = let _1 =
let _1 =
let ys =
-# 260 "menhir/standard.mly"
+# 260 "<standard.mly>"
( List.flatten xss )
-# 41218 "parsing/parser.ml"
+# 41938 "parsing/parser.ml"
in
let xs =
let items =
-# 862 "parsing/parser.mly"
+# 883 "parsing/parser.mly"
( [] )
-# 41224 "parsing/parser.ml"
+# 41944 "parsing/parser.ml"
in
-# 1247 "parsing/parser.mly"
+# 1297 "parsing/parser.mly"
( items )
-# 41229 "parsing/parser.ml"
+# 41949 "parsing/parser.ml"
in
-# 267 "menhir/standard.mly"
+# 267 "<standard.mly>"
( xs @ ys )
-# 41235 "parsing/parser.ml"
+# 41955 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in
let _endpos = _endpos__1_ in
let _startpos = _startpos__1_ in
-# 784 "parsing/parser.mly"
+# 805 "parsing/parser.mly"
( extra_str _startpos _endpos _1 )
-# 41244 "parsing/parser.ml"
+# 41964 "parsing/parser.ml"
in
-# 1240 "parsing/parser.mly"
+# 1290 "parsing/parser.mly"
( _1 )
-# 41250 "parsing/parser.ml"
+# 41970 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.structure) = let _1 =
let _1 =
let ys =
-# 260 "menhir/standard.mly"
+# 260 "<standard.mly>"
( List.flatten xss )
-# 41291 "parsing/parser.ml"
+# 42011 "parsing/parser.ml"
in
let xs =
let items =
let _1 =
let _1 =
let attrs =
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 41301 "parsing/parser.ml"
+# 42021 "parsing/parser.ml"
in
-# 1254 "parsing/parser.mly"
+# 1304 "parsing/parser.mly"
( mkstrexp e attrs )
-# 41306 "parsing/parser.ml"
+# 42026 "parsing/parser.ml"
in
let _startpos__1_ = _startpos_e_ in
let _startpos = _startpos__1_ in
-# 796 "parsing/parser.mly"
+# 817 "parsing/parser.mly"
( text_str _startpos @ [_1] )
-# 41314 "parsing/parser.ml"
+# 42034 "parsing/parser.ml"
in
let _startpos__1_ = _startpos_e_ in
let _endpos = _endpos__1_ in
let _startpos = _startpos__1_ in
-# 815 "parsing/parser.mly"
+# 836 "parsing/parser.mly"
( mark_rhs_docs _startpos _endpos;
_1 )
-# 41324 "parsing/parser.ml"
+# 42044 "parsing/parser.ml"
in
-# 864 "parsing/parser.mly"
+# 885 "parsing/parser.mly"
( x )
-# 41330 "parsing/parser.ml"
+# 42050 "parsing/parser.ml"
in
-# 1247 "parsing/parser.mly"
+# 1297 "parsing/parser.mly"
( items )
-# 41336 "parsing/parser.ml"
+# 42056 "parsing/parser.ml"
in
-# 267 "menhir/standard.mly"
+# 267 "<standard.mly>"
( xs @ ys )
-# 41342 "parsing/parser.ml"
+# 42062 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_e_) in
let _endpos = _endpos__1_ in
let _startpos = _startpos__1_ in
-# 784 "parsing/parser.mly"
+# 805 "parsing/parser.mly"
( extra_str _startpos _endpos _1 )
-# 41351 "parsing/parser.ml"
+# 42071 "parsing/parser.ml"
in
-# 1240 "parsing/parser.mly"
+# 1290 "parsing/parser.mly"
( _1 )
-# 41357 "parsing/parser.ml"
+# 42077 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1269 "parsing/parser.mly"
+# 1319 "parsing/parser.mly"
( val_of_let_bindings ~loc:_sloc _1 )
-# 41385 "parsing/parser.ml"
+# 42105 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _2 =
let _1 = _1_inlined1 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 41421 "parsing/parser.ml"
+# 42141 "parsing/parser.ml"
in
let _endpos__2_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1272 "parsing/parser.mly"
+# 1322 "parsing/parser.mly"
( let docs = symbol_docs _sloc in
Pstr_extension (_1, add_docs_attrs docs _2) )
-# 41432 "parsing/parser.ml"
+# 42152 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 831 "parsing/parser.mly"
+# 852 "parsing/parser.mly"
( mkstr ~loc:_sloc _1 )
-# 41442 "parsing/parser.ml"
+# 42162 "parsing/parser.ml"
in
-# 1303 "parsing/parser.mly"
+# 1353 "parsing/parser.mly"
( _1 )
-# 41448 "parsing/parser.ml"
+# 42168 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.structure_item) = let _1 =
let _1 =
-# 1275 "parsing/parser.mly"
+# 1325 "parsing/parser.mly"
( Pstr_attribute _1 )
-# 41474 "parsing/parser.ml"
+# 42194 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 831 "parsing/parser.mly"
+# 852 "parsing/parser.mly"
( mkstr ~loc:_sloc _1 )
-# 41482 "parsing/parser.ml"
+# 42202 "parsing/parser.ml"
in
-# 1303 "parsing/parser.mly"
+# 1353 "parsing/parser.mly"
( _1 )
-# 41488 "parsing/parser.ml"
+# 42208 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.structure_item) = let _1 =
let _1 =
-# 1279 "parsing/parser.mly"
+# 1329 "parsing/parser.mly"
( pstr_primitive _1 )
-# 41514 "parsing/parser.ml"
+# 42234 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 848 "parsing/parser.mly"
+# 869 "parsing/parser.mly"
( wrap_mkstr_ext ~loc:_sloc _1 )
-# 41522 "parsing/parser.ml"
+# 42242 "parsing/parser.ml"
in
-# 1303 "parsing/parser.mly"
+# 1353 "parsing/parser.mly"
( _1 )
-# 41528 "parsing/parser.ml"
+# 42248 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.structure_item) = let _1 =
let _1 =
-# 1281 "parsing/parser.mly"
+# 1331 "parsing/parser.mly"
( pstr_primitive _1 )
-# 41554 "parsing/parser.ml"
+# 42274 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 848 "parsing/parser.mly"
+# 869 "parsing/parser.mly"
( wrap_mkstr_ext ~loc:_sloc _1 )
-# 41562 "parsing/parser.ml"
+# 42282 "parsing/parser.ml"
in
-# 1303 "parsing/parser.mly"
+# 1353 "parsing/parser.mly"
( _1 )
-# 41568 "parsing/parser.ml"
+# 42288 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let _1 =
let _1 =
-# 1023 "parsing/parser.mly"
+# 1044 "parsing/parser.mly"
( let (x, b) = a in x, b :: bs )
-# 41605 "parsing/parser.ml"
+# 42325 "parsing/parser.ml"
in
-# 2792 "parsing/parser.mly"
+# 2842 "parsing/parser.mly"
( _1 )
-# 41610 "parsing/parser.ml"
+# 42330 "parsing/parser.ml"
in
-# 2775 "parsing/parser.mly"
+# 2825 "parsing/parser.mly"
( _1 )
-# 41616 "parsing/parser.ml"
+# 42336 "parsing/parser.ml"
in
-# 1283 "parsing/parser.mly"
+# 1333 "parsing/parser.mly"
( pstr_type _1 )
-# 41622 "parsing/parser.ml"
+# 42342 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_bs_, _startpos_a_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 848 "parsing/parser.mly"
+# 869 "parsing/parser.mly"
( wrap_mkstr_ext ~loc:_sloc _1 )
-# 41632 "parsing/parser.ml"
+# 42352 "parsing/parser.ml"
in
-# 1303 "parsing/parser.mly"
+# 1353 "parsing/parser.mly"
( _1 )
-# 41638 "parsing/parser.ml"
+# 42358 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 41725 "parsing/parser.ml"
+# 42445 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let cs =
-# 1015 "parsing/parser.mly"
+# 1036 "parsing/parser.mly"
( List.rev xs )
-# 41732 "parsing/parser.ml"
+# 42452 "parsing/parser.ml"
in
let tid =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 41742 "parsing/parser.ml"
+# 42462 "parsing/parser.ml"
in
let _4 =
-# 3512 "parsing/parser.mly"
+# 3574 "parsing/parser.mly"
( Recursive )
-# 41748 "parsing/parser.ml"
+# 42468 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 41755 "parsing/parser.ml"
+# 42475 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3029 "parsing/parser.mly"
+# 3079 "parsing/parser.mly"
( let docs = symbol_docs _sloc in
let attrs = attrs1 @ attrs2 in
Te.mk tid cs ~params ~priv ~attrs ~docs,
ext )
-# 41767 "parsing/parser.ml"
+# 42487 "parsing/parser.ml"
in
-# 3012 "parsing/parser.mly"
+# 3062 "parsing/parser.mly"
( _1 )
-# 41773 "parsing/parser.ml"
+# 42493 "parsing/parser.ml"
in
-# 1285 "parsing/parser.mly"
+# 1335 "parsing/parser.mly"
( pstr_typext _1 )
-# 41779 "parsing/parser.ml"
+# 42499 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 848 "parsing/parser.mly"
+# 869 "parsing/parser.mly"
( wrap_mkstr_ext ~loc:_sloc _1 )
-# 41789 "parsing/parser.ml"
+# 42509 "parsing/parser.ml"
in
-# 1303 "parsing/parser.mly"
+# 1353 "parsing/parser.mly"
( _1 )
-# 41795 "parsing/parser.ml"
+# 42515 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs2 =
let _1 = _1_inlined4 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 41889 "parsing/parser.ml"
+# 42609 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined4_ in
let cs =
-# 1015 "parsing/parser.mly"
+# 1036 "parsing/parser.mly"
( List.rev xs )
-# 41896 "parsing/parser.ml"
+# 42616 "parsing/parser.ml"
in
let tid =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 41906 "parsing/parser.ml"
+# 42626 "parsing/parser.ml"
in
let _4 =
let _startpos = _startpos__1_ in
let _loc = (_startpos, _endpos) in
-# 3513 "parsing/parser.mly"
+# 3575 "parsing/parser.mly"
( not_expecting _loc "nonrec flag" )
-# 41917 "parsing/parser.ml"
+# 42637 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 41925 "parsing/parser.ml"
+# 42645 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3029 "parsing/parser.mly"
+# 3079 "parsing/parser.mly"
( let docs = symbol_docs _sloc in
let attrs = attrs1 @ attrs2 in
Te.mk tid cs ~params ~priv ~attrs ~docs,
ext )
-# 41937 "parsing/parser.ml"
+# 42657 "parsing/parser.ml"
in
-# 3012 "parsing/parser.mly"
+# 3062 "parsing/parser.mly"
( _1 )
-# 41943 "parsing/parser.ml"
+# 42663 "parsing/parser.ml"
in
-# 1285 "parsing/parser.mly"
+# 1335 "parsing/parser.mly"
( pstr_typext _1 )
-# 41949 "parsing/parser.ml"
+# 42669 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined4_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 848 "parsing/parser.mly"
+# 869 "parsing/parser.mly"
( wrap_mkstr_ext ~loc:_sloc _1 )
-# 41959 "parsing/parser.ml"
+# 42679 "parsing/parser.ml"
in
-# 1303 "parsing/parser.mly"
+# 1353 "parsing/parser.mly"
( _1 )
-# 41965 "parsing/parser.ml"
+# 42685 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.structure_item) = let _1 =
let _1 =
-# 1287 "parsing/parser.mly"
+# 1337 "parsing/parser.mly"
( pstr_exception _1 )
-# 41991 "parsing/parser.ml"
+# 42711 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 848 "parsing/parser.mly"
+# 869 "parsing/parser.mly"
( wrap_mkstr_ext ~loc:_sloc _1 )
-# 41999 "parsing/parser.ml"
+# 42719 "parsing/parser.ml"
in
-# 1303 "parsing/parser.mly"
+# 1353 "parsing/parser.mly"
( _1 )
-# 42005 "parsing/parser.ml"
+# 42725 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 42070 "parsing/parser.ml"
+# 42790 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 42082 "parsing/parser.ml"
+# 42802 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 42090 "parsing/parser.ml"
+# 42810 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1313 "parsing/parser.mly"
+# 1363 "parsing/parser.mly"
( let docs = symbol_docs _sloc in
let loc = make_loc _sloc in
let attrs = attrs1 @ attrs2 in
let body = Mb.mk name body ~attrs ~loc ~docs in
Pstr_module body, ext )
-# 42103 "parsing/parser.ml"
+# 42823 "parsing/parser.ml"
in
-# 1289 "parsing/parser.mly"
+# 1339 "parsing/parser.mly"
( _1 )
-# 42109 "parsing/parser.ml"
+# 42829 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 848 "parsing/parser.mly"
+# 869 "parsing/parser.mly"
( wrap_mkstr_ext ~loc:_sloc _1 )
-# 42119 "parsing/parser.ml"
+# 42839 "parsing/parser.ml"
in
-# 1303 "parsing/parser.mly"
+# 1353 "parsing/parser.mly"
( _1 )
-# 42125 "parsing/parser.ml"
+# 42845 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 42206 "parsing/parser.ml"
+# 42926 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 42218 "parsing/parser.ml"
+# 42938 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 42226 "parsing/parser.ml"
+# 42946 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1347 "parsing/parser.mly"
+# 1397 "parsing/parser.mly"
(
let loc = make_loc _sloc in
let attrs = attrs1 @ attrs2 in
ext,
Mb.mk name body ~attrs ~loc ~docs
)
-# 42241 "parsing/parser.ml"
+# 42961 "parsing/parser.ml"
in
-# 1023 "parsing/parser.mly"
+# 1044 "parsing/parser.mly"
( let (x, b) = a in x, b :: bs )
-# 42247 "parsing/parser.ml"
+# 42967 "parsing/parser.ml"
in
-# 1335 "parsing/parser.mly"
+# 1385 "parsing/parser.mly"
( _1 )
-# 42253 "parsing/parser.ml"
+# 42973 "parsing/parser.ml"
in
-# 1291 "parsing/parser.mly"
+# 1341 "parsing/parser.mly"
( pstr_recmodule _1 )
-# 42259 "parsing/parser.ml"
+# 42979 "parsing/parser.ml"
in
let _endpos__1_ = _endpos_bs_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 848 "parsing/parser.mly"
+# 869 "parsing/parser.mly"
( wrap_mkstr_ext ~loc:_sloc _1 )
-# 42269 "parsing/parser.ml"
+# 42989 "parsing/parser.ml"
in
-# 1303 "parsing/parser.mly"
+# 1353 "parsing/parser.mly"
( _1 )
-# 42275 "parsing/parser.ml"
+# 42995 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.structure_item) = let _1 =
let _1 =
-# 1293 "parsing/parser.mly"
+# 1343 "parsing/parser.mly"
( let (body, ext) = _1 in (Pstr_modtype body, ext) )
-# 42301 "parsing/parser.ml"
+# 43021 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 848 "parsing/parser.mly"
+# 869 "parsing/parser.mly"
( wrap_mkstr_ext ~loc:_sloc _1 )
-# 42309 "parsing/parser.ml"
+# 43029 "parsing/parser.ml"
in
-# 1303 "parsing/parser.mly"
+# 1353 "parsing/parser.mly"
( _1 )
-# 42315 "parsing/parser.ml"
+# 43035 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.structure_item) = let _1 =
let _1 =
-# 1295 "parsing/parser.mly"
+# 1345 "parsing/parser.mly"
( let (body, ext) = _1 in (Pstr_open body, ext) )
-# 42341 "parsing/parser.ml"
+# 43061 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 848 "parsing/parser.mly"
+# 869 "parsing/parser.mly"
( wrap_mkstr_ext ~loc:_sloc _1 )
-# 42349 "parsing/parser.ml"
+# 43069 "parsing/parser.ml"
in
-# 1303 "parsing/parser.mly"
+# 1353 "parsing/parser.mly"
( _1 )
-# 42355 "parsing/parser.ml"
+# 43075 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in
let body : (Parsetree.class_expr) = Obj.magic body in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 42427 "parsing/parser.ml"
+# 43147 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let params : ((Parsetree.core_type * Asttypes.variance) list) = Obj.magic params in
let virt : (Asttypes.virtual_flag) = Obj.magic virt in
let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 42447 "parsing/parser.ml"
+# 43167 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 42459 "parsing/parser.ml"
+# 43179 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 42467 "parsing/parser.ml"
+# 43187 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1665 "parsing/parser.mly"
+# 1715 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
ext,
Ci.mk id body ~virt ~params ~attrs ~loc ~docs
)
-# 42482 "parsing/parser.ml"
+# 43202 "parsing/parser.ml"
in
-# 1023 "parsing/parser.mly"
+# 1044 "parsing/parser.mly"
( let (x, b) = a in x, b :: bs )
-# 42488 "parsing/parser.ml"
+# 43208 "parsing/parser.ml"
in
-# 1654 "parsing/parser.mly"
+# 1704 "parsing/parser.mly"
( _1 )
-# 42494 "parsing/parser.ml"
+# 43214 "parsing/parser.ml"
in
-# 1297 "parsing/parser.mly"
+# 1347 "parsing/parser.mly"
( let (ext, l) = _1 in (Pstr_class l, ext) )
-# 42500 "parsing/parser.ml"
+# 43220 "parsing/parser.ml"
in
let _endpos__1_ = _endpos_bs_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 848 "parsing/parser.mly"
+# 869 "parsing/parser.mly"
( wrap_mkstr_ext ~loc:_sloc _1 )
-# 42510 "parsing/parser.ml"
+# 43230 "parsing/parser.ml"
in
-# 1303 "parsing/parser.mly"
+# 1353 "parsing/parser.mly"
( _1 )
-# 42516 "parsing/parser.ml"
+# 43236 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.structure_item) = let _1 =
let _1 =
-# 1299 "parsing/parser.mly"
+# 1349 "parsing/parser.mly"
( let (ext, l) = _1 in (Pstr_class_type l, ext) )
-# 42542 "parsing/parser.ml"
+# 43262 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 848 "parsing/parser.mly"
+# 869 "parsing/parser.mly"
( wrap_mkstr_ext ~loc:_sloc _1 )
-# 42550 "parsing/parser.ml"
+# 43270 "parsing/parser.ml"
in
-# 1303 "parsing/parser.mly"
+# 1353 "parsing/parser.mly"
( _1 )
-# 42556 "parsing/parser.ml"
+# 43276 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let attrs2 =
let _1 = _1_inlined2 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 42614 "parsing/parser.ml"
+# 43334 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined2_ in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 42623 "parsing/parser.ml"
+# 43343 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1384 "parsing/parser.mly"
+# 1434 "parsing/parser.mly"
(
let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
let docs = symbol_docs _sloc in
Incl.mk thing ~attrs ~loc ~docs, ext
)
-# 42637 "parsing/parser.ml"
+# 43357 "parsing/parser.ml"
in
-# 1301 "parsing/parser.mly"
+# 1351 "parsing/parser.mly"
( pstr_include _1 )
-# 42643 "parsing/parser.ml"
+# 43363 "parsing/parser.ml"
in
let _endpos__1_ = _endpos__1_inlined2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 848 "parsing/parser.mly"
+# 869 "parsing/parser.mly"
( wrap_mkstr_ext ~loc:_sloc _1 )
-# 42653 "parsing/parser.ml"
+# 43373 "parsing/parser.ml"
in
-# 1303 "parsing/parser.mly"
+# 1353 "parsing/parser.mly"
( _1 )
-# 42659 "parsing/parser.ml"
+# 43379 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3575 "parsing/parser.mly"
+# 3637 "parsing/parser.mly"
( "-" )
-# 42684 "parsing/parser.ml"
+# 43404 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (string) =
-# 3576 "parsing/parser.mly"
+# 3638 "parsing/parser.mly"
( "-." )
-# 42709 "parsing/parser.ml"
+# 43429 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.row_field) = let _5 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 42764 "parsing/parser.ml"
+# 43484 "parsing/parser.ml"
in
let _endpos__5_ = _endpos__1_inlined1_ in
let _4 =
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 42773 "parsing/parser.ml"
+# 43493 "parsing/parser.ml"
in
-# 926 "parsing/parser.mly"
+# 947 "parsing/parser.mly"
( xs )
-# 42778 "parsing/parser.ml"
+# 43498 "parsing/parser.ml"
in
-# 3299 "parsing/parser.mly"
+# 3349 "parsing/parser.mly"
( _1 )
-# 42784 "parsing/parser.ml"
+# 43504 "parsing/parser.ml"
in
let _1 =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 42794 "parsing/parser.ml"
+# 43514 "parsing/parser.ml"
in
let _endpos = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3285 "parsing/parser.mly"
+# 3335 "parsing/parser.mly"
( let info = symbol_info _endpos in
let attrs = add_info_attrs info _5 in
Rf.tag ~loc:(make_loc _sloc) ~attrs _1 _3 _4 )
-# 42805 "parsing/parser.ml"
+# 43525 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.row_field) = let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 42839 "parsing/parser.ml"
+# 43559 "parsing/parser.ml"
in
let _endpos__2_ = _endpos__1_inlined1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 42850 "parsing/parser.ml"
+# 43570 "parsing/parser.ml"
in
let _endpos = _endpos__2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3289 "parsing/parser.mly"
+# 3339 "parsing/parser.mly"
( let info = symbol_info _endpos in
let attrs = add_info_attrs info _2 in
Rf.tag ~loc:(make_loc _sloc) ~attrs _1 true [] )
-# 42861 "parsing/parser.ml"
+# 43581 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_inlined1_ in
let _v : (Parsetree.toplevel_phrase) = let arg =
-# 124 "menhir/standard.mly"
+# 124 "<standard.mly>"
( None )
-# 42893 "parsing/parser.ml"
+# 43613 "parsing/parser.ml"
in
let _endpos_arg_ = _endpos__1_inlined1_ in
let dir =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 42904 "parsing/parser.ml"
+# 43624 "parsing/parser.ml"
in
let _endpos = _endpos_arg_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3475 "parsing/parser.mly"
+# 3537 "parsing/parser.mly"
( mk_directive ~loc:_sloc dir arg )
-# 42913 "parsing/parser.ml"
+# 43633 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _1_inlined2 : (
-# 680 "parsing/parser.mly"
- (string * string option)
-# 42946 "parsing/parser.ml"
+# 685 "parsing/parser.mly"
+ (string * Location.t * string option)
+# 43666 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in
let _1 : unit = Obj.magic _1 in
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in
let x =
let _1 =
-# 3479 "parsing/parser.mly"
- ( let (s, _) = _1 in Pdir_string s )
-# 42959 "parsing/parser.ml"
+# 3541 "parsing/parser.mly"
+ ( let (s, _, _) = _1 in Pdir_string s )
+# 43679 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 853 "parsing/parser.mly"
+# 874 "parsing/parser.mly"
( mk_directive_arg ~loc:_sloc _1 )
-# 42967 "parsing/parser.ml"
+# 43687 "parsing/parser.ml"
in
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 42973 "parsing/parser.ml"
+# 43693 "parsing/parser.ml"
in
let _endpos_arg_ = _endpos__1_inlined2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 42985 "parsing/parser.ml"
+# 43705 "parsing/parser.ml"
in
let _endpos = _endpos_arg_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3475 "parsing/parser.mly"
+# 3537 "parsing/parser.mly"
( mk_directive ~loc:_sloc dir arg )
-# 42994 "parsing/parser.ml"
+# 43714 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _1_inlined2 : (
-# 628 "parsing/parser.mly"
+# 633 "parsing/parser.mly"
(string * char option)
-# 43027 "parsing/parser.ml"
+# 43747 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in
let _1 : unit = Obj.magic _1 in
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in
let x =
let _1 =
-# 3480 "parsing/parser.mly"
+# 3542 "parsing/parser.mly"
( let (n, m) = _1 in Pdir_int (n ,m) )
-# 43040 "parsing/parser.ml"
+# 43760 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 853 "parsing/parser.mly"
+# 874 "parsing/parser.mly"
( mk_directive_arg ~loc:_sloc _1 )
-# 43048 "parsing/parser.ml"
+# 43768 "parsing/parser.ml"
in
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 43054 "parsing/parser.ml"
+# 43774 "parsing/parser.ml"
in
let _endpos_arg_ = _endpos__1_inlined2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 43066 "parsing/parser.ml"
+# 43786 "parsing/parser.ml"
in
let _endpos = _endpos_arg_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3475 "parsing/parser.mly"
+# 3537 "parsing/parser.mly"
( mk_directive ~loc:_sloc dir arg )
-# 43075 "parsing/parser.ml"
+# 43795 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in
let x =
let _1 =
-# 3481 "parsing/parser.mly"
+# 3543 "parsing/parser.mly"
( Pdir_ident _1 )
-# 43117 "parsing/parser.ml"
+# 43837 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 853 "parsing/parser.mly"
+# 874 "parsing/parser.mly"
( mk_directive_arg ~loc:_sloc _1 )
-# 43125 "parsing/parser.ml"
+# 43845 "parsing/parser.ml"
in
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 43131 "parsing/parser.ml"
+# 43851 "parsing/parser.ml"
in
let _endpos_arg_ = _endpos__1_inlined2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 43143 "parsing/parser.ml"
+# 43863 "parsing/parser.ml"
in
let _endpos = _endpos_arg_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3475 "parsing/parser.mly"
+# 3537 "parsing/parser.mly"
( mk_directive ~loc:_sloc dir arg )
-# 43152 "parsing/parser.ml"
+# 43872 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in
let x =
let _1 =
-# 3482 "parsing/parser.mly"
+# 3544 "parsing/parser.mly"
( Pdir_ident _1 )
-# 43194 "parsing/parser.ml"
+# 43914 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 853 "parsing/parser.mly"
+# 874 "parsing/parser.mly"
( mk_directive_arg ~loc:_sloc _1 )
-# 43202 "parsing/parser.ml"
+# 43922 "parsing/parser.ml"
in
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 43208 "parsing/parser.ml"
+# 43928 "parsing/parser.ml"
in
let _endpos_arg_ = _endpos__1_inlined2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 43220 "parsing/parser.ml"
+# 43940 "parsing/parser.ml"
in
let _endpos = _endpos_arg_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3475 "parsing/parser.mly"
+# 3537 "parsing/parser.mly"
( mk_directive ~loc:_sloc dir arg )
-# 43229 "parsing/parser.ml"
+# 43949 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in
let x =
let _1 =
-# 3483 "parsing/parser.mly"
+# 3545 "parsing/parser.mly"
( Pdir_bool false )
-# 43271 "parsing/parser.ml"
+# 43991 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 853 "parsing/parser.mly"
+# 874 "parsing/parser.mly"
( mk_directive_arg ~loc:_sloc _1 )
-# 43279 "parsing/parser.ml"
+# 43999 "parsing/parser.ml"
in
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 43285 "parsing/parser.ml"
+# 44005 "parsing/parser.ml"
in
let _endpos_arg_ = _endpos__1_inlined2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 43297 "parsing/parser.ml"
+# 44017 "parsing/parser.ml"
in
let _endpos = _endpos_arg_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3475 "parsing/parser.mly"
+# 3537 "parsing/parser.mly"
( mk_directive ~loc:_sloc dir arg )
-# 43306 "parsing/parser.ml"
+# 44026 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in
let x =
let _1 =
-# 3484 "parsing/parser.mly"
+# 3546 "parsing/parser.mly"
( Pdir_bool true )
-# 43348 "parsing/parser.ml"
+# 44068 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 853 "parsing/parser.mly"
+# 874 "parsing/parser.mly"
( mk_directive_arg ~loc:_sloc _1 )
-# 43356 "parsing/parser.ml"
+# 44076 "parsing/parser.ml"
in
-# 126 "menhir/standard.mly"
+# 126 "<standard.mly>"
( Some x )
-# 43362 "parsing/parser.ml"
+# 44082 "parsing/parser.ml"
in
let _endpos_arg_ = _endpos__1_inlined2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 43374 "parsing/parser.ml"
+# 44094 "parsing/parser.ml"
in
let _endpos = _endpos_arg_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3475 "parsing/parser.mly"
+# 3537 "parsing/parser.mly"
( mk_directive ~loc:_sloc dir arg )
-# 43383 "parsing/parser.ml"
+# 44103 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_e_ in
let _endpos = _endpos__2_ in
let _v : (
-# 772 "parsing/parser.mly"
+# 781 "parsing/parser.mly"
(Parsetree.toplevel_phrase)
-# 43422 "parsing/parser.ml"
+# 44142 "parsing/parser.ml"
) = let _1 =
let _1 =
let _1 =
let attrs =
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 43429 "parsing/parser.ml"
+# 44149 "parsing/parser.ml"
in
-# 1254 "parsing/parser.mly"
+# 1304 "parsing/parser.mly"
( mkstrexp e attrs )
-# 43434 "parsing/parser.ml"
+# 44154 "parsing/parser.ml"
in
let _startpos__1_ = _startpos_e_ in
let _startpos = _startpos__1_ in
-# 796 "parsing/parser.mly"
+# 817 "parsing/parser.mly"
( text_str _startpos @ [_1] )
-# 43442 "parsing/parser.ml"
+# 44162 "parsing/parser.ml"
in
let _startpos__1_ = _startpos_e_ in
let _endpos = _endpos__1_ in
let _startpos = _startpos__1_ in
-# 784 "parsing/parser.mly"
+# 805 "parsing/parser.mly"
( extra_str _startpos _endpos _1 )
-# 43451 "parsing/parser.ml"
+# 44171 "parsing/parser.ml"
in
-# 1061 "parsing/parser.mly"
+# 1082 "parsing/parser.mly"
( Ptop_def _1 )
-# 43457 "parsing/parser.ml"
+# 44177 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xss_ in
let _endpos = _endpos__2_ in
let _v : (
-# 772 "parsing/parser.mly"
+# 781 "parsing/parser.mly"
(Parsetree.toplevel_phrase)
-# 43489 "parsing/parser.ml"
+# 44209 "parsing/parser.ml"
) = let _1 =
let _1 =
-# 260 "menhir/standard.mly"
+# 260 "<standard.mly>"
( List.flatten xss )
-# 43494 "parsing/parser.ml"
+# 44214 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in
let _endpos = _endpos__1_ in
let _startpos = _startpos__1_ in
-# 784 "parsing/parser.mly"
+# 805 "parsing/parser.mly"
( extra_str _startpos _endpos _1 )
-# 43502 "parsing/parser.ml"
+# 44222 "parsing/parser.ml"
in
-# 1065 "parsing/parser.mly"
+# 1086 "parsing/parser.mly"
( Ptop_def _1 )
-# 43508 "parsing/parser.ml"
+# 44228 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (
-# 772 "parsing/parser.mly"
+# 781 "parsing/parser.mly"
(Parsetree.toplevel_phrase)
-# 43540 "parsing/parser.ml"
+# 44260 "parsing/parser.ml"
) =
-# 1069 "parsing/parser.mly"
+# 1090 "parsing/parser.mly"
( _1 )
-# 43544 "parsing/parser.ml"
+# 44264 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (
-# 772 "parsing/parser.mly"
+# 781 "parsing/parser.mly"
(Parsetree.toplevel_phrase)
-# 43569 "parsing/parser.ml"
+# 44289 "parsing/parser.ml"
) =
-# 1072 "parsing/parser.mly"
+# 1093 "parsing/parser.mly"
( raise End_of_file )
-# 43573 "parsing/parser.ml"
+# 44293 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_ty_ in
let _endpos = _endpos_ty_ in
let _v : (Parsetree.core_type) =
-# 3191 "parsing/parser.mly"
+# 3241 "parsing/parser.mly"
( ty )
-# 43598 "parsing/parser.ml"
+# 44318 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1 =
let tys =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 43626 "parsing/parser.ml"
+# 44346 "parsing/parser.ml"
in
-# 954 "parsing/parser.mly"
+# 975 "parsing/parser.mly"
( xs )
-# 43631 "parsing/parser.ml"
+# 44351 "parsing/parser.ml"
in
-# 3194 "parsing/parser.mly"
+# 3244 "parsing/parser.mly"
( Ptyp_tuple tys )
-# 43637 "parsing/parser.ml"
+# 44357 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_xs_) in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 43647 "parsing/parser.ml"
+# 44367 "parsing/parser.ml"
in
-# 3196 "parsing/parser.mly"
+# 3246 "parsing/parser.mly"
( _1 )
-# 43653 "parsing/parser.ml"
+# 44373 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.core_type option * Parsetree.core_type option) =
-# 2539 "parsing/parser.mly"
+# 2589 "parsing/parser.mly"
( (Some _2, None) )
-# 43685 "parsing/parser.ml"
+# 44405 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : (Parsetree.core_type option * Parsetree.core_type option) =
-# 2540 "parsing/parser.mly"
+# 2590 "parsing/parser.mly"
( (Some _2, Some _4) )
-# 43731 "parsing/parser.ml"
+# 44451 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.core_type option * Parsetree.core_type option) =
-# 2541 "parsing/parser.mly"
+# 2591 "parsing/parser.mly"
( (None, Some _2) )
-# 43763 "parsing/parser.ml"
+# 44483 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.core_type option * Parsetree.core_type option) =
-# 2542 "parsing/parser.mly"
+# 2592 "parsing/parser.mly"
( syntax_error() )
-# 43795 "parsing/parser.ml"
+# 44515 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.core_type option * Parsetree.core_type option) =
-# 2543 "parsing/parser.mly"
+# 2593 "parsing/parser.mly"
( syntax_error() )
-# 43827 "parsing/parser.ml"
+# 44547 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) =
-# 2866 "parsing/parser.mly"
+# 2916 "parsing/parser.mly"
( (Ptype_abstract, Public, None) )
-# 43845 "parsing/parser.ml"
+# 44565 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) =
-# 2868 "parsing/parser.mly"
+# 2918 "parsing/parser.mly"
( _2 )
-# 43877 "parsing/parser.ml"
+# 44597 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.endp = _endpos__1_;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
- let _1 : (
-# 642 "parsing/parser.mly"
- (string)
-# 43898 "parsing/parser.ml"
- ) = Obj.magic _1 in
- let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
- let _startpos = _startpos__1_ in
- let _endpos = _endpos__1_ in
- let _v : (Longident.t) =
-# 3442 "parsing/parser.mly"
- ( Lident _1 )
-# 43906 "parsing/parser.ml"
- in
- {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = Obj.repr _v;
- MenhirLib.EngineTypes.startp = _startpos;
- MenhirLib.EngineTypes.endp = _endpos;
- MenhirLib.EngineTypes.next = _menhir_stack;
- });
- (fun _menhir_env ->
- let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
- let {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _3;
- MenhirLib.EngineTypes.startp = _startpos__3_;
- MenhirLib.EngineTypes.endp = _endpos__3_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _2;
- MenhirLib.EngineTypes.startp = _startpos__2_;
- MenhirLib.EngineTypes.endp = _endpos__2_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = _1;
- MenhirLib.EngineTypes.startp = _startpos__1_;
- MenhirLib.EngineTypes.endp = _endpos__1_;
- MenhirLib.EngineTypes.next = _menhir_stack;
- };
- };
- } = _menhir_stack in
- let _3 : (
-# 642 "parsing/parser.mly"
- (string)
-# 43939 "parsing/parser.ml"
- ) = Obj.magic _3 in
- let _2 : unit = Obj.magic _2 in
let _1 : (Longident.t) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
- let _endpos = _endpos__3_ in
+ let _endpos = _endpos__1_ in
let _v : (Longident.t) =
-# 3443 "parsing/parser.mly"
- ( Ldot(_1, _3) )
-# 43949 "parsing/parser.ml"
+# 3500 "parsing/parser.mly"
+ ( _1 )
+# 44622 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Parsetree.core_type * Asttypes.variance) =
-# 2883 "parsing/parser.mly"
+# 2933 "parsing/parser.mly"
( _2, _1 )
-# 43981 "parsing/parser.ml"
+# 44654 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : ((Parsetree.core_type * Asttypes.variance) list) =
-# 2876 "parsing/parser.mly"
+# 2926 "parsing/parser.mly"
( [] )
-# 43999 "parsing/parser.ml"
+# 44672 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_p_ in
let _endpos = _endpos_p_ in
let _v : ((Parsetree.core_type * Asttypes.variance) list) =
-# 2878 "parsing/parser.mly"
+# 2928 "parsing/parser.mly"
( [p] )
-# 44024 "parsing/parser.ml"
+# 44697 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__3_ in
let _v : ((Parsetree.core_type * Asttypes.variance) list) = let ps =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 44064 "parsing/parser.ml"
+# 44737 "parsing/parser.ml"
in
-# 926 "parsing/parser.mly"
+# 947 "parsing/parser.mly"
( xs )
-# 44069 "parsing/parser.ml"
+# 44742 "parsing/parser.ml"
in
-# 2880 "parsing/parser.mly"
+# 2930 "parsing/parser.mly"
( ps )
-# 44075 "parsing/parser.ml"
+# 44748 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos_tyvar_ in
let _v : (Parsetree.core_type) = let _1 =
let _1 =
-# 2888 "parsing/parser.mly"
+# 2938 "parsing/parser.mly"
( Ptyp_var tyvar )
-# 44108 "parsing/parser.ml"
+# 44781 "parsing/parser.ml"
in
let _endpos__1_ = _endpos_tyvar_ in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 44117 "parsing/parser.ml"
+# 44790 "parsing/parser.ml"
in
-# 2891 "parsing/parser.mly"
+# 2941 "parsing/parser.mly"
( _1 )
-# 44123 "parsing/parser.ml"
+# 44796 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__1_ in
let _v : (Parsetree.core_type) = let _1 =
let _1 =
-# 2890 "parsing/parser.mly"
+# 2940 "parsing/parser.mly"
( Ptyp_any )
-# 44149 "parsing/parser.ml"
+# 44822 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 829 "parsing/parser.mly"
+# 850 "parsing/parser.mly"
( mktyp ~loc:_sloc _1 )
-# 44157 "parsing/parser.ml"
+# 44830 "parsing/parser.ml"
in
-# 2891 "parsing/parser.mly"
+# 2941 "parsing/parser.mly"
( _1 )
-# 44163 "parsing/parser.ml"
+# 44836 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Asttypes.variance) =
-# 2895 "parsing/parser.mly"
+# 2945 "parsing/parser.mly"
( Invariant )
-# 44181 "parsing/parser.ml"
+# 44854 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.variance) =
-# 2896 "parsing/parser.mly"
+# 2946 "parsing/parser.mly"
( Covariant )
-# 44206 "parsing/parser.ml"
+# 44879 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.variance) =
-# 2897 "parsing/parser.mly"
+# 2947 "parsing/parser.mly"
( Contravariant )
-# 44231 "parsing/parser.ml"
+# 44904 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_xss_ in
let _endpos = _endpos__2_ in
let _v : (
-# 774 "parsing/parser.mly"
+# 783 "parsing/parser.mly"
(Parsetree.toplevel_phrase list)
-# 44263 "parsing/parser.ml"
+# 44936 "parsing/parser.ml"
) = let _1 =
let _1 =
let ys =
-# 260 "menhir/standard.mly"
+# 260 "<standard.mly>"
( List.flatten xss )
-# 44269 "parsing/parser.ml"
+# 44942 "parsing/parser.ml"
in
let xs =
let _1 =
-# 862 "parsing/parser.mly"
+# 883 "parsing/parser.mly"
( [] )
-# 44275 "parsing/parser.ml"
+# 44948 "parsing/parser.ml"
in
-# 1092 "parsing/parser.mly"
+# 1113 "parsing/parser.mly"
( _1 )
-# 44280 "parsing/parser.ml"
+# 44953 "parsing/parser.ml"
in
-# 267 "menhir/standard.mly"
+# 267 "<standard.mly>"
( xs @ ys )
-# 44286 "parsing/parser.ml"
+# 44959 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in
let _endpos = _endpos__1_ in
let _startpos = _startpos__1_ in
-# 788 "parsing/parser.mly"
+# 809 "parsing/parser.mly"
( extra_def _startpos _endpos _1 )
-# 44295 "parsing/parser.ml"
+# 44968 "parsing/parser.ml"
in
-# 1085 "parsing/parser.mly"
+# 1106 "parsing/parser.mly"
( _1 )
-# 44301 "parsing/parser.ml"
+# 44974 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_e_ in
let _endpos = _endpos__2_ in
let _v : (
-# 774 "parsing/parser.mly"
+# 783 "parsing/parser.mly"
(Parsetree.toplevel_phrase list)
-# 44347 "parsing/parser.ml"
+# 45020 "parsing/parser.ml"
) = let _1 =
let _1 =
let ys =
-# 260 "menhir/standard.mly"
+# 260 "<standard.mly>"
( List.flatten xss )
-# 44353 "parsing/parser.ml"
+# 45026 "parsing/parser.ml"
in
let xs =
let _1 =
let _1 =
let _1 =
let attrs =
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 44363 "parsing/parser.ml"
+# 45036 "parsing/parser.ml"
in
-# 1254 "parsing/parser.mly"
+# 1304 "parsing/parser.mly"
( mkstrexp e attrs )
-# 44368 "parsing/parser.ml"
+# 45041 "parsing/parser.ml"
in
-# 806 "parsing/parser.mly"
+# 827 "parsing/parser.mly"
( Ptop_def [_1] )
-# 44374 "parsing/parser.ml"
+# 45047 "parsing/parser.ml"
in
let _startpos__1_ = _startpos_e_ in
let _startpos = _startpos__1_ in
-# 804 "parsing/parser.mly"
+# 825 "parsing/parser.mly"
( text_def _startpos @ [_1] )
-# 44382 "parsing/parser.ml"
+# 45055 "parsing/parser.ml"
in
-# 864 "parsing/parser.mly"
+# 885 "parsing/parser.mly"
( x )
-# 44388 "parsing/parser.ml"
+# 45061 "parsing/parser.ml"
in
-# 1092 "parsing/parser.mly"
+# 1113 "parsing/parser.mly"
( _1 )
-# 44394 "parsing/parser.ml"
+# 45067 "parsing/parser.ml"
in
-# 267 "menhir/standard.mly"
+# 267 "<standard.mly>"
( xs @ ys )
-# 44400 "parsing/parser.ml"
+# 45073 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_e_) in
let _endpos = _endpos__1_ in
let _startpos = _startpos__1_ in
-# 788 "parsing/parser.mly"
+# 809 "parsing/parser.mly"
( extra_def _startpos _endpos _1 )
-# 44409 "parsing/parser.ml"
+# 45082 "parsing/parser.ml"
in
-# 1085 "parsing/parser.mly"
+# 1106 "parsing/parser.mly"
( _1 )
-# 44415 "parsing/parser.ml"
- in
- {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = Obj.repr _v;
- MenhirLib.EngineTypes.startp = _startpos;
- MenhirLib.EngineTypes.endp = _endpos;
- MenhirLib.EngineTypes.next = _menhir_stack;
- });
- (fun _menhir_env ->
- let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
- let {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = _1;
- MenhirLib.EngineTypes.startp = _startpos__1_;
- MenhirLib.EngineTypes.endp = _endpos__1_;
- MenhirLib.EngineTypes.next = _menhir_stack;
- } = _menhir_stack in
- let _1 : (
-# 642 "parsing/parser.mly"
- (string)
-# 44436 "parsing/parser.ml"
- ) = Obj.magic _1 in
- let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
- let _startpos = _startpos__1_ in
- let _endpos = _endpos__1_ in
- let _v : (string) =
-# 3369 "parsing/parser.mly"
- ( _1 )
-# 44444 "parsing/parser.ml"
+# 45088 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : unit = Obj.magic _3 in
- let _2 : (string) = Obj.magic _2 in
+ let _2 : (Asttypes.label) = Obj.magic _2 in
let _1 : unit = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
- let _v : (string) =
-# 3370 "parsing/parser.mly"
+ let _v : (Asttypes.label) =
+# 3419 "parsing/parser.mly"
( _2 )
-# 44483 "parsing/parser.ml"
+# 45127 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : unit = Obj.magic _3 in
- let _2 : (string) = Obj.magic _2 in
+ let _2 : (Asttypes.label) = Obj.magic _2 in
let _1 : unit = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
- let _v : (string) = let _loc__3_ = (_startpos__3_, _endpos__3_) in
+ let _v : (Asttypes.label) = let _loc__3_ = (_startpos__3_, _endpos__3_) in
let _loc__1_ = (_startpos__1_, _endpos__1_) in
-# 3371 "parsing/parser.mly"
+# 3420 "parsing/parser.mly"
( unclosed "(" _loc__1_ ")" _loc__3_ )
-# 44524 "parsing/parser.ml"
+# 45168 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
- let _v : (string) = let _loc__2_ = (_startpos__2_, _endpos__2_) in
+ let _v : (Asttypes.label) = let _loc__2_ = (_startpos__2_, _endpos__2_) in
-# 3372 "parsing/parser.mly"
+# 3421 "parsing/parser.mly"
( expecting _loc__2_ "operator" )
-# 44557 "parsing/parser.ml"
+# 45201 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
- let _v : (string) = let _loc__3_ = (_startpos__3_, _endpos__3_) in
+ let _v : (Asttypes.label) = let _loc__3_ = (_startpos__3_, _endpos__3_) in
-# 3373 "parsing/parser.mly"
+# 3422 "parsing/parser.mly"
( expecting _loc__3_ "module-expr" )
-# 44597 "parsing/parser.ml"
+# 45241 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.endp = _endpos__1_;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
- let _1 : (string) = Obj.magic _1 in
+ let _1 : (
+# 647 "parsing/parser.mly"
+ (string)
+# 45262 "parsing/parser.ml"
+ ) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
- let _v : (Longident.t) =
+ let _v : (Asttypes.label) =
# 3425 "parsing/parser.mly"
- ( Lident _1 )
-# 44622 "parsing/parser.ml"
+ ( _1 )
+# 45270 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
(fun _menhir_env ->
let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
let {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _3;
- MenhirLib.EngineTypes.startp = _startpos__3_;
- MenhirLib.EngineTypes.endp = _endpos__3_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _;
- MenhirLib.EngineTypes.semv = _2;
- MenhirLib.EngineTypes.startp = _startpos__2_;
- MenhirLib.EngineTypes.endp = _endpos__2_;
- MenhirLib.EngineTypes.next = {
- MenhirLib.EngineTypes.state = _menhir_s;
- MenhirLib.EngineTypes.semv = _1;
- MenhirLib.EngineTypes.startp = _startpos__1_;
- MenhirLib.EngineTypes.endp = _endpos__1_;
- MenhirLib.EngineTypes.next = _menhir_stack;
- };
- };
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ } = _menhir_stack in
+ let _1 : (Asttypes.label) = Obj.magic _1 in
+ let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__1_ in
+ let _v : (Asttypes.label) =
+# 3426 "parsing/parser.mly"
+ ( _1 )
+# 45295 "parsing/parser.ml"
+ in
+ {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = _1;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
- let _3 : (string) = Obj.magic _3 in
- let _2 : unit = Obj.magic _2 in
let _1 : (Longident.t) = Obj.magic _1 in
let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in
let _startpos = _startpos__1_ in
- let _endpos = _endpos__3_ in
+ let _endpos = _endpos__1_ in
let _v : (Longident.t) =
-# 3426 "parsing/parser.mly"
- ( Ldot(_1, _3) )
-# 44661 "parsing/parser.ml"
+# 3494 "parsing/parser.mly"
+ ( _1 )
+# 45320 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let ty : (Parsetree.core_type) = Obj.magic ty in
let _5 : unit = Obj.magic _5 in
let _1_inlined1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 44708 "parsing/parser.ml"
+# 45367 "parsing/parser.ml"
) = Obj.magic _1_inlined1 in
let mutable_ : (Asttypes.mutable_flag) = Obj.magic mutable_ in
let _1 : (Parsetree.attributes) = Obj.magic _1 in
Parsetree.attributes) = let label =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 44722 "parsing/parser.ml"
+# 45381 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 44730 "parsing/parser.ml"
+# 45389 "parsing/parser.ml"
in
let attrs =
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 44736 "parsing/parser.ml"
+# 45395 "parsing/parser.ml"
in
let _1 =
-# 3568 "parsing/parser.mly"
+# 3630 "parsing/parser.mly"
( Fresh )
-# 44741 "parsing/parser.ml"
+# 45400 "parsing/parser.ml"
in
-# 1805 "parsing/parser.mly"
+# 1855 "parsing/parser.mly"
( (label, mutable_, Cfk_virtual ty), attrs )
-# 44746 "parsing/parser.ml"
+# 45405 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _6 : (Parsetree.expression) = Obj.magic _6 in
let _5 : unit = Obj.magic _5 in
let _1_inlined1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 44793 "parsing/parser.ml"
+# 45452 "parsing/parser.ml"
) = Obj.magic _1_inlined1 in
let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in
let _1 : (Parsetree.attributes) = Obj.magic _1 in
Parsetree.attributes) = let _4 =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 44807 "parsing/parser.ml"
+# 45466 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 44815 "parsing/parser.ml"
+# 45474 "parsing/parser.ml"
in
let _2 =
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 44821 "parsing/parser.ml"
+# 45480 "parsing/parser.ml"
in
let _1 =
-# 3571 "parsing/parser.mly"
+# 3633 "parsing/parser.mly"
( Fresh )
-# 44826 "parsing/parser.ml"
+# 45485 "parsing/parser.ml"
in
-# 1807 "parsing/parser.mly"
+# 1857 "parsing/parser.mly"
( (_4, _3, Cfk_concrete (_1, _6)), _2 )
-# 44831 "parsing/parser.ml"
+# 45490 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _6 : (Parsetree.expression) = Obj.magic _6 in
let _5 : unit = Obj.magic _5 in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 44884 "parsing/parser.ml"
+# 45543 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
Parsetree.attributes) = let _4 =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 44899 "parsing/parser.ml"
+# 45558 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 44907 "parsing/parser.ml"
+# 45566 "parsing/parser.ml"
in
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 44915 "parsing/parser.ml"
+# 45574 "parsing/parser.ml"
in
let _1 =
-# 3572 "parsing/parser.mly"
+# 3634 "parsing/parser.mly"
( Override )
-# 44921 "parsing/parser.ml"
+# 45580 "parsing/parser.ml"
in
-# 1807 "parsing/parser.mly"
+# 1857 "parsing/parser.mly"
( (_4, _3, Cfk_concrete (_1, _6)), _2 )
-# 44926 "parsing/parser.ml"
+# 45585 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _6 : unit = Obj.magic _6 in
let _5 : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic _5 in
let _1_inlined1 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 44980 "parsing/parser.ml"
+# 45639 "parsing/parser.ml"
) = Obj.magic _1_inlined1 in
let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in
let _1 : (Parsetree.attributes) = Obj.magic _1 in
Parsetree.attributes) = let _4 =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 44994 "parsing/parser.ml"
+# 45653 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 45002 "parsing/parser.ml"
+# 45661 "parsing/parser.ml"
in
let _startpos__4_ = _startpos__1_inlined1_ in
let _2 =
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 45009 "parsing/parser.ml"
+# 45668 "parsing/parser.ml"
in
let (_endpos__2_, _startpos__2_) = (_endpos__1_, _startpos__1_) in
let _1 =
-# 3571 "parsing/parser.mly"
+# 3633 "parsing/parser.mly"
( Fresh )
-# 45015 "parsing/parser.ml"
+# 45674 "parsing/parser.ml"
in
let (_endpos__1_, _startpos__1_) = (_endpos__0_, _endpos__0_) in
let _endpos = _endpos__7_ in
_startpos__4_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1810 "parsing/parser.mly"
+# 1860 "parsing/parser.mly"
( let e = mkexp_constraint ~loc:_sloc _7 _5 in
(_4, _3, Cfk_concrete (_1, e)), _2
)
-# 45035 "parsing/parser.ml"
+# 45694 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _6 : unit = Obj.magic _6 in
let _5 : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic _5 in
let _1_inlined2 : (
-# 642 "parsing/parser.mly"
+# 647 "parsing/parser.mly"
(string)
-# 45095 "parsing/parser.ml"
+# 45754 "parsing/parser.ml"
) = Obj.magic _1_inlined2 in
let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
Parsetree.attributes) = let _4 =
let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in
let _1 =
-# 3343 "parsing/parser.mly"
+# 3393 "parsing/parser.mly"
( _1 )
-# 45110 "parsing/parser.ml"
+# 45769 "parsing/parser.ml"
in
let _endpos = _endpos__1_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 45118 "parsing/parser.ml"
+# 45777 "parsing/parser.ml"
in
let _startpos__4_ = _startpos__1_inlined2_ in
let _2 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 45127 "parsing/parser.ml"
+# 45786 "parsing/parser.ml"
in
let (_endpos__2_, _startpos__2_) = (_endpos__1_inlined1_, _startpos__1_inlined1_) in
let _1 =
-# 3572 "parsing/parser.mly"
+# 3634 "parsing/parser.mly"
( Override )
-# 45134 "parsing/parser.ml"
+# 45793 "parsing/parser.ml"
in
let _endpos = _endpos__7_ in
let _symbolstartpos = if _startpos__1_ != _endpos__1_ then
_startpos__4_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 1810 "parsing/parser.mly"
+# 1860 "parsing/parser.mly"
( let e = mkexp_constraint ~loc:_sloc _7 _5 in
(_4, _3, Cfk_concrete (_1, e)), _2
)
-# 45153 "parsing/parser.ml"
+# 45812 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in
let ty : (Parsetree.core_type) = Obj.magic ty in
let _5 : unit = Obj.magic _5 in
- let _1_inlined2 : (string) = Obj.magic _1_inlined2 in
+ let _1_inlined2 : (Asttypes.label) = Obj.magic _1_inlined2 in
let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in
let ext : (string Asttypes.loc option) = Obj.magic ext in
let _1 : unit = Obj.magic _1 in
let _v : (Parsetree.value_description * string Asttypes.loc option) = let attrs2 =
let _1 = _1_inlined3 in
-# 3665 "parsing/parser.mly"
+# 3727 "parsing/parser.mly"
( _1 )
-# 45222 "parsing/parser.ml"
+# 45881 "parsing/parser.ml"
in
let _endpos_attrs2_ = _endpos__1_inlined3_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 45234 "parsing/parser.ml"
+# 45893 "parsing/parser.ml"
in
let attrs1 =
let _1 = _1_inlined1 in
-# 3669 "parsing/parser.mly"
+# 3731 "parsing/parser.mly"
( _1 )
-# 45242 "parsing/parser.ml"
+# 45901 "parsing/parser.ml"
in
let _endpos = _endpos_attrs2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 2737 "parsing/parser.mly"
+# 2787 "parsing/parser.mly"
( let attrs = attrs1 @ attrs2 in
let loc = make_loc _sloc in
let docs = symbol_docs _sloc in
Val.mk id ty ~attrs ~loc ~docs,
ext )
-# 45255 "parsing/parser.ml"
+# 45914 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in
let _endpos = _startpos in
let _v : (Asttypes.virtual_flag) =
-# 3532 "parsing/parser.mly"
+# 3594 "parsing/parser.mly"
( Concrete )
-# 45273 "parsing/parser.ml"
+# 45932 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.virtual_flag) =
-# 3533 "parsing/parser.mly"
+# 3595 "parsing/parser.mly"
( Virtual )
-# 45298 "parsing/parser.ml"
+# 45957 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.mutable_flag) =
-# 3556 "parsing/parser.mly"
+# 3618 "parsing/parser.mly"
( Immutable )
-# 45323 "parsing/parser.ml"
+# 45982 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Asttypes.mutable_flag) =
-# 3557 "parsing/parser.mly"
+# 3619 "parsing/parser.mly"
( Mutable )
-# 45355 "parsing/parser.ml"
+# 46014 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Asttypes.mutable_flag) =
-# 3558 "parsing/parser.mly"
+# 3620 "parsing/parser.mly"
( Mutable )
-# 45387 "parsing/parser.ml"
+# 46046 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.private_flag) =
-# 3563 "parsing/parser.mly"
+# 3625 "parsing/parser.mly"
( Public )
-# 45412 "parsing/parser.ml"
+# 46071 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Asttypes.private_flag) =
-# 3564 "parsing/parser.mly"
+# 3626 "parsing/parser.mly"
( Private )
-# 45444 "parsing/parser.ml"
+# 46103 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Asttypes.private_flag) =
-# 3565 "parsing/parser.mly"
+# 3627 "parsing/parser.mly"
( Private )
-# 45476 "parsing/parser.ml"
+# 46135 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.with_constraint) = let _6 =
let _1 =
let xs =
-# 253 "menhir/standard.mly"
+# 253 "<standard.mly>"
( List.rev xs )
-# 45538 "parsing/parser.ml"
+# 46197 "parsing/parser.ml"
in
-# 876 "parsing/parser.mly"
+# 897 "parsing/parser.mly"
( xs )
-# 45543 "parsing/parser.ml"
+# 46202 "parsing/parser.ml"
in
-# 2837 "parsing/parser.mly"
+# 2887 "parsing/parser.mly"
( _1 )
-# 45549 "parsing/parser.ml"
+# 46208 "parsing/parser.ml"
in
let _endpos__6_ = _endpos_xs_ in
let _5 =
let _1 = _1_inlined2 in
-# 3139 "parsing/parser.mly"
+# 3189 "parsing/parser.mly"
( _1 )
-# 45558 "parsing/parser.ml"
+# 46217 "parsing/parser.ml"
in
let _3 =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 45569 "parsing/parser.ml"
+# 46228 "parsing/parser.ml"
in
let _endpos = _endpos__6_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3062 "parsing/parser.mly"
+# 3112 "parsing/parser.mly"
( let lident = loc_last _3 in
Pwith_type
(_3,
~manifest:_5
~priv:_4
~loc:(make_loc _sloc))) )
-# 45586 "parsing/parser.ml"
+# 46245 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _v : (Parsetree.with_constraint) = let _5 =
let _1 = _1_inlined2 in
-# 3139 "parsing/parser.mly"
+# 3189 "parsing/parser.mly"
( _1 )
-# 45641 "parsing/parser.ml"
+# 46300 "parsing/parser.ml"
in
let _endpos__5_ = _endpos__1_inlined2_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 45653 "parsing/parser.ml"
+# 46312 "parsing/parser.ml"
in
let _endpos = _endpos__5_ in
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 3075 "parsing/parser.mly"
+# 3125 "parsing/parser.mly"
( let lident = loc_last _3 in
Pwith_typesubst
(_3,
~params:_2
~manifest:_5
~loc:(make_loc _sloc))) )
-# 45668 "parsing/parser.ml"
+# 46327 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 45719 "parsing/parser.ml"
+# 46378 "parsing/parser.ml"
in
let _2 =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 45730 "parsing/parser.ml"
+# 46389 "parsing/parser.ml"
in
-# 3083 "parsing/parser.mly"
+# 3133 "parsing/parser.mly"
( Pwith_module (_2, _4) )
-# 45736 "parsing/parser.ml"
+# 46395 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 45787 "parsing/parser.ml"
+# 46446 "parsing/parser.ml"
in
let _2 =
let _symbolstartpos = _startpos__1_ in
let _sloc = (_symbolstartpos, _endpos) in
-# 792 "parsing/parser.mly"
+# 813 "parsing/parser.mly"
( mkrhs _1 _sloc )
-# 45798 "parsing/parser.ml"
+# 46457 "parsing/parser.ml"
in
-# 3085 "parsing/parser.mly"
+# 3135 "parsing/parser.mly"
( Pwith_modsubst (_2, _4) )
-# 45804 "parsing/parser.ml"
+# 46463 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (Asttypes.private_flag) =
-# 3088 "parsing/parser.mly"
+# 3138 "parsing/parser.mly"
( Public )
-# 45829 "parsing/parser.ml"
+# 46488 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (Asttypes.private_flag) =
-# 3089 "parsing/parser.mly"
+# 3139 "parsing/parser.mly"
( Private )
-# 45861 "parsing/parser.ml"
+# 46520 "parsing/parser.ml"
in
{
MenhirLib.EngineTypes.state = _menhir_s;
let use_file =
fun lexer lexbuf ->
- (Obj.magic (MenhirInterpreter.entry 1765 lexer lexbuf) : (
-# 774 "parsing/parser.mly"
+ (Obj.magic (MenhirInterpreter.entry 1802 lexer lexbuf) : (
+# 783 "parsing/parser.mly"
(Parsetree.toplevel_phrase list)
-# 45892 "parsing/parser.ml"
+# 46551 "parsing/parser.ml"
))
and toplevel_phrase =
fun lexer lexbuf ->
- (Obj.magic (MenhirInterpreter.entry 1744 lexer lexbuf) : (
-# 772 "parsing/parser.mly"
+ (Obj.magic (MenhirInterpreter.entry 1782 lexer lexbuf) : (
+# 781 "parsing/parser.mly"
(Parsetree.toplevel_phrase)
-# 45900 "parsing/parser.ml"
+# 46559 "parsing/parser.ml"
+ ))
+
+and parse_val_longident =
+ fun lexer lexbuf ->
+ (Obj.magic (MenhirInterpreter.entry 1776 lexer lexbuf) : (
+# 793 "parsing/parser.mly"
+ (Longident.t)
+# 46567 "parsing/parser.ml"
))
and parse_pattern =
fun lexer lexbuf ->
- (Obj.magic (MenhirInterpreter.entry 1740 lexer lexbuf) : (
-# 780 "parsing/parser.mly"
+ (Obj.magic (MenhirInterpreter.entry 1772 lexer lexbuf) : (
+# 789 "parsing/parser.mly"
(Parsetree.pattern)
-# 45908 "parsing/parser.ml"
+# 46575 "parsing/parser.ml"
+ ))
+
+and parse_mty_longident =
+ fun lexer lexbuf ->
+ (Obj.magic (MenhirInterpreter.entry 1768 lexer lexbuf) : (
+# 795 "parsing/parser.mly"
+ (Longident.t)
+# 46583 "parsing/parser.ml"
+ ))
+
+and parse_mod_longident =
+ fun lexer lexbuf ->
+ (Obj.magic (MenhirInterpreter.entry 1764 lexer lexbuf) : (
+# 799 "parsing/parser.mly"
+ (Longident.t)
+# 46591 "parsing/parser.ml"
+ ))
+
+and parse_mod_ext_longident =
+ fun lexer lexbuf ->
+ (Obj.magic (MenhirInterpreter.entry 1760 lexer lexbuf) : (
+# 797 "parsing/parser.mly"
+ (Longident.t)
+# 46599 "parsing/parser.ml"
))
and parse_expression =
fun lexer lexbuf ->
- (Obj.magic (MenhirInterpreter.entry 1736 lexer lexbuf) : (
-# 778 "parsing/parser.mly"
+ (Obj.magic (MenhirInterpreter.entry 1756 lexer lexbuf) : (
+# 787 "parsing/parser.mly"
(Parsetree.expression)
-# 45916 "parsing/parser.ml"
+# 46607 "parsing/parser.ml"
))
and parse_core_type =
fun lexer lexbuf ->
- (Obj.magic (MenhirInterpreter.entry 1732 lexer lexbuf) : (
-# 776 "parsing/parser.mly"
+ (Obj.magic (MenhirInterpreter.entry 1752 lexer lexbuf) : (
+# 785 "parsing/parser.mly"
(Parsetree.core_type)
-# 45924 "parsing/parser.ml"
+# 46615 "parsing/parser.ml"
+ ))
+
+and parse_constr_longident =
+ fun lexer lexbuf ->
+ (Obj.magic (MenhirInterpreter.entry 1748 lexer lexbuf) : (
+# 791 "parsing/parser.mly"
+ (Longident.t)
+# 46623 "parsing/parser.ml"
+ ))
+
+and parse_any_longident =
+ fun lexer lexbuf ->
+ (Obj.magic (MenhirInterpreter.entry 1730 lexer lexbuf) : (
+# 801 "parsing/parser.mly"
+ (Longident.t)
+# 46631 "parsing/parser.ml"
))
and interface =
fun lexer lexbuf ->
- (Obj.magic (MenhirInterpreter.entry 1728 lexer lexbuf) : (
-# 770 "parsing/parser.mly"
+ (Obj.magic (MenhirInterpreter.entry 1726 lexer lexbuf) : (
+# 779 "parsing/parser.mly"
(Parsetree.signature)
-# 45932 "parsing/parser.ml"
+# 46639 "parsing/parser.ml"
))
and implementation =
fun lexer lexbuf ->
(Obj.magic (MenhirInterpreter.entry 0 lexer lexbuf) : (
-# 768 "parsing/parser.mly"
+# 777 "parsing/parser.mly"
(Parsetree.structure)
-# 45940 "parsing/parser.ml"
+# 46647 "parsing/parser.ml"
))
module Incremental = struct
let use_file =
fun initial_position ->
- (Obj.magic (MenhirInterpreter.start 1765 initial_position) : (
-# 774 "parsing/parser.mly"
+ (Obj.magic (MenhirInterpreter.start 1802 initial_position) : (
+# 783 "parsing/parser.mly"
(Parsetree.toplevel_phrase list)
-# 45950 "parsing/parser.ml"
+# 46657 "parsing/parser.ml"
) MenhirInterpreter.checkpoint)
and toplevel_phrase =
fun initial_position ->
- (Obj.magic (MenhirInterpreter.start 1744 initial_position) : (
-# 772 "parsing/parser.mly"
+ (Obj.magic (MenhirInterpreter.start 1782 initial_position) : (
+# 781 "parsing/parser.mly"
(Parsetree.toplevel_phrase)
-# 45958 "parsing/parser.ml"
+# 46665 "parsing/parser.ml"
+ ) MenhirInterpreter.checkpoint)
+
+ and parse_val_longident =
+ fun initial_position ->
+ (Obj.magic (MenhirInterpreter.start 1776 initial_position) : (
+# 793 "parsing/parser.mly"
+ (Longident.t)
+# 46673 "parsing/parser.ml"
) MenhirInterpreter.checkpoint)
and parse_pattern =
fun initial_position ->
- (Obj.magic (MenhirInterpreter.start 1740 initial_position) : (
-# 780 "parsing/parser.mly"
+ (Obj.magic (MenhirInterpreter.start 1772 initial_position) : (
+# 789 "parsing/parser.mly"
(Parsetree.pattern)
-# 45966 "parsing/parser.ml"
+# 46681 "parsing/parser.ml"
+ ) MenhirInterpreter.checkpoint)
+
+ and parse_mty_longident =
+ fun initial_position ->
+ (Obj.magic (MenhirInterpreter.start 1768 initial_position) : (
+# 795 "parsing/parser.mly"
+ (Longident.t)
+# 46689 "parsing/parser.ml"
+ ) MenhirInterpreter.checkpoint)
+
+ and parse_mod_longident =
+ fun initial_position ->
+ (Obj.magic (MenhirInterpreter.start 1764 initial_position) : (
+# 799 "parsing/parser.mly"
+ (Longident.t)
+# 46697 "parsing/parser.ml"
+ ) MenhirInterpreter.checkpoint)
+
+ and parse_mod_ext_longident =
+ fun initial_position ->
+ (Obj.magic (MenhirInterpreter.start 1760 initial_position) : (
+# 797 "parsing/parser.mly"
+ (Longident.t)
+# 46705 "parsing/parser.ml"
) MenhirInterpreter.checkpoint)
and parse_expression =
fun initial_position ->
- (Obj.magic (MenhirInterpreter.start 1736 initial_position) : (
-# 778 "parsing/parser.mly"
+ (Obj.magic (MenhirInterpreter.start 1756 initial_position) : (
+# 787 "parsing/parser.mly"
(Parsetree.expression)
-# 45974 "parsing/parser.ml"
+# 46713 "parsing/parser.ml"
) MenhirInterpreter.checkpoint)
and parse_core_type =
fun initial_position ->
- (Obj.magic (MenhirInterpreter.start 1732 initial_position) : (
-# 776 "parsing/parser.mly"
+ (Obj.magic (MenhirInterpreter.start 1752 initial_position) : (
+# 785 "parsing/parser.mly"
(Parsetree.core_type)
-# 45982 "parsing/parser.ml"
+# 46721 "parsing/parser.ml"
+ ) MenhirInterpreter.checkpoint)
+
+ and parse_constr_longident =
+ fun initial_position ->
+ (Obj.magic (MenhirInterpreter.start 1748 initial_position) : (
+# 791 "parsing/parser.mly"
+ (Longident.t)
+# 46729 "parsing/parser.ml"
+ ) MenhirInterpreter.checkpoint)
+
+ and parse_any_longident =
+ fun initial_position ->
+ (Obj.magic (MenhirInterpreter.start 1730 initial_position) : (
+# 801 "parsing/parser.mly"
+ (Longident.t)
+# 46737 "parsing/parser.ml"
) MenhirInterpreter.checkpoint)
and interface =
fun initial_position ->
- (Obj.magic (MenhirInterpreter.start 1728 initial_position) : (
-# 770 "parsing/parser.mly"
+ (Obj.magic (MenhirInterpreter.start 1726 initial_position) : (
+# 779 "parsing/parser.mly"
(Parsetree.signature)
-# 45990 "parsing/parser.ml"
+# 46745 "parsing/parser.ml"
) MenhirInterpreter.checkpoint)
and implementation =
fun initial_position ->
(Obj.magic (MenhirInterpreter.start 0 initial_position) : (
-# 768 "parsing/parser.mly"
+# 777 "parsing/parser.mly"
(Parsetree.structure)
-# 45998 "parsing/parser.ml"
+# 46753 "parsing/parser.ml"
) MenhirInterpreter.checkpoint)
end
-# 3695 "parsing/parser.mly"
+# 3761 "parsing/parser.mly"
-# 46006 "parsing/parser.ml"
+# 46761 "parsing/parser.ml"
-# 269 "menhir/standard.mly"
+# 269 "<standard.mly>"
-# 46011 "parsing/parser.ml"
+# 46766 "parsing/parser.ml"
| TILDE
| THEN
| STRUCT
- | STRING of (string * string option)
+ | STRING of (string * Location.t * string option)
| STAR
| SIG
| SEMISEMI
| REC
| RBRACKET
| RBRACE
+ | QUOTED_STRING_ITEM of (string * Location.t * string * Location.t * string option)
+ | QUOTED_STRING_EXPR of (string * Location.t * string * Location.t * string option)
| QUOTE
| QUESTION
| PRIVATE
val toplevel_phrase: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Parsetree.toplevel_phrase)
+val parse_val_longident: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Longident.t)
+
val parse_pattern: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Parsetree.pattern)
+val parse_mty_longident: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Longident.t)
+
+val parse_mod_longident: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Longident.t)
+
+val parse_mod_ext_longident: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Longident.t)
+
val parse_expression: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Parsetree.expression)
val parse_core_type: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Parsetree.core_type)
+val parse_constr_longident: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Longident.t)
+
+val parse_any_longident: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Longident.t)
+
val interface: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Parsetree.signature)
val implementation: (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Parsetree.structure)
val toplevel_phrase: Lexing.position -> (Parsetree.toplevel_phrase) MenhirInterpreter.checkpoint
+ val parse_val_longident: Lexing.position -> (Longident.t) MenhirInterpreter.checkpoint
+
val parse_pattern: Lexing.position -> (Parsetree.pattern) MenhirInterpreter.checkpoint
+ val parse_mty_longident: Lexing.position -> (Longident.t) MenhirInterpreter.checkpoint
+
+ val parse_mod_longident: Lexing.position -> (Longident.t) MenhirInterpreter.checkpoint
+
+ val parse_mod_ext_longident: Lexing.position -> (Longident.t) MenhirInterpreter.checkpoint
+
val parse_expression: Lexing.position -> (Parsetree.expression) MenhirInterpreter.checkpoint
val parse_core_type: Lexing.position -> (Parsetree.core_type) MenhirInterpreter.checkpoint
+ val parse_constr_longident: Lexing.position -> (Longident.t) MenhirInterpreter.checkpoint
+
+ val parse_any_longident: Lexing.position -> (Longident.t) MenhirInterpreter.checkpoint
+
val interface: Lexing.position -> (Parsetree.signature) MenhirInterpreter.checkpoint
val implementation: Lexing.position -> (Parsetree.structure) MenhirInterpreter.checkpoint
open Lambda
open Switch
open Instruct
+open Debuginfo.Scoped_location
(**** Label generation ****)
| Kpop _ :: c -> is_tailcall c
| _ -> false
+(* Will this primitive result in an OCaml call which would benefit
+ from the tail call optimization? *)
+
+let preserve_tailcall_for_prim = function
+ Pidentity | Popaque | Pdirapply | Prevapply | Psequor | Psequand ->
+ true
+ | Pbytes_to_string | Pbytes_of_string | Pignore | Pgetglobal _ | Psetglobal _
+ | Pmakeblock _ | Pfield _ | Pfield_computed | Psetfield _
+ | Psetfield_computed _ | Pfloatfield _ | Psetfloatfield _ | Pduprecord _
+ | Pccall _ | Praise _ | Pnot | Pnegint | Paddint | Psubint | Pmulint
+ | Pdivint _ | Pmodint _ | Pandint | Porint | Pxorint | Plslint | Plsrint
+ | Pasrint | Pintcomp _ | Poffsetint _ | Poffsetref _ | Pintoffloat
+ | Pfloatofint | Pnegfloat | Pabsfloat | Paddfloat | Psubfloat | Pmulfloat
+ | Pdivfloat | Pfloatcomp _ | Pstringlength | Pstringrefu | Pstringrefs
+ | Pcompare_ints | Pcompare_floats | Pcompare_bints _
+ | Pbyteslength | Pbytesrefu | Pbytessetu | Pbytesrefs | Pbytessets
+ | Pmakearray _ | Pduparray _ | Parraylength _ | Parrayrefu _ | Parraysetu _
+ | Parrayrefs _ | Parraysets _ | Pisint | Pisout | Pbintofint _ | Pintofbint _
+ | Pcvtbint _ | Pnegbint _ | Paddbint _ | Psubbint _ | Pmulbint _ | Pdivbint _
+ | Pmodbint _ | Pandbint _ | Porbint _ | Pxorbint _ | Plslbint _ | Plsrbint _
+ | Pasrbint _ | Pbintcomp _ | Pbigarrayref _ | Pbigarrayset _ | Pbigarraydim _
+ | Pstring_load_16 _ | Pstring_load_32 _ | Pstring_load_64 _ | Pbytes_load_16 _
+ | Pbytes_load_32 _ | Pbytes_load_64 _ | Pbytes_set_16 _ | Pbytes_set_32 _
+ | Pbytes_set_64 _ | Pbigstring_load_16 _ | Pbigstring_load_32 _
+ | Pbigstring_load_64 _ | Pbigstring_set_16 _ | Pbigstring_set_32 _
+ | Pbigstring_set_64 _ | Pctconst _ | Pbswap16 | Pbbswap _ | Pint_as_pointer ->
+ false
+
(* Add a Kpop N instruction in front of a continuation *)
let rec add_pop n cont =
(**** Merging consecutive events ****)
let copy_event ev kind info repr =
- { ev_pos = 0; (* patched in emitcode *)
- ev_module = ev.ev_module;
- ev_loc = ev.ev_loc;
+ { ev with
+ ev_pos = 0; (* patched in emitcode *)
ev_kind = kind;
ev_info = info;
- ev_typenv = ev.ev_typenv;
- ev_typsubst = ev.ev_typsubst;
- ev_compenv = ev.ev_compenv;
- ev_stacksize = ev.ev_stacksize;
ev_repr = repr }
let merge_infos ev ev' =
Kevent ev' :: cont -> weaken_event (merge_events ev ev') cont
| cont -> weaken_event ev cont
+(* Pseudo events are ignored by the debugger. They are only used for
+ generating backtraces.
+
+ We prefer adding this event here rather than in lambda generation
+ 1) there are many different situations where a Pmakeblock can
+ be generated
+ 2) we prefer inserting a pseudo event rather than an event after
+ to prevent the debugger to stop at every single allocation. *)
+let add_pseudo_event loc modname c =
+ if !Clflags.debug then
+ let ev_defname = string_of_scoped_location loc in
+ let ev =
+ { ev_pos = 0; (* patched in emitcode *)
+ ev_module = modname;
+ ev_loc = to_location loc;
+ ev_defname;
+ ev_kind = Event_pseudo;
+ ev_info = Event_other; (* Dummy *)
+ ev_typenv = Env.Env_empty; (* Dummy *)
+ ev_typsubst = Subst.identity; (* Dummy *)
+ ev_compenv = empty_env; (* Dummy *)
+ ev_stacksize = 0; (* Dummy *)
+ ev_repr = Event_none } (* Dummy *)
+ in
+ add_event ev c
+ else c
+
(**** Compilation of a lambda expression ****)
let try_blocks = ref [] (* list of stack size for each nested try block *)
Pgetglobal id -> Kgetglobal id
| Psetglobal id -> Ksetglobal id
| Pintcomp cmp -> Kintcomp cmp
- | Pmakeblock(tag, _mut, _) -> Kmakeblock(List.length args, tag)
+ | Pcompare_ints -> Kccall("caml_int_compare", 2)
+ | Pcompare_floats -> Kccall("caml_float_compare", 2)
+ | Pcompare_bints bi -> comp_bint_primitive bi "compare" args
| Pfield n -> Kgetfield n
| Pfield_computed -> Kgetvectitem
| Psetfield(n, _ptr, _init) -> Ksetfield n
| Psetfield_computed(_ptr, _init) -> Ksetvectitem
- | Pfloatfield n -> Kgetfloatfield n
| Psetfloatfield (n, _init) -> Ksetfloatfield n
| Pduprecord _ -> Kccall("caml_obj_dup", 1)
| Pccall p -> Kccall(p.prim_name, p.prim_arity)
comp_args env args' (sz + 3)
(getmethod :: Kapply nargs :: cont1)
end
- | Lfunction{params; body} -> (* assume kind = Curried *)
+ | Lfunction{params; body; loc} -> (* assume kind = Curried *)
+ let cont = add_pseudo_event loc !compunit_name cont in
let lbl = new_label() in
let fv = Ident.Set.elements(free_variables exp) in
let to_compile =
(Kpush::
Kconst (Const_base (Const_int n))::
Kaddint::cont)
- | Lprim(Pmakearray (kind, _), args, _) ->
+ | Lprim(Pmakearray (kind, _), args, loc) ->
+ let cont = add_pseudo_event loc !compunit_name cont in
begin match kind with
Pintarray | Paddrarray ->
comp_args env args sz (Kmakeblock(List.length args, 0) :: cont)
| CFnge -> Kccall("caml_ge_float", 2) :: Kboolnot :: cont
in
comp_args env args sz cont
+ | Lprim(Pmakeblock(tag, _mut, _), args, loc) ->
+ let cont = add_pseudo_event loc !compunit_name cont in
+ comp_args env args sz (Kmakeblock(List.length args, tag) :: cont)
+ | Lprim(Pfloatfield n, args, loc) ->
+ let cont = add_pseudo_event loc !compunit_name cont in
+ comp_args env args sz (Kgetfloatfield n :: cont)
| Lprim(p, args, _) ->
comp_args env args sz (comp_primitive p args :: cont)
| Lstaticcatch (body, (i, vars) , handler) ->
fatal_error "Bytegen.comp_expr: assign"
end
| Levent(lam, lev) ->
+ let ev_defname = match lev.lev_loc with
+ | Loc_unknown -> "??"
+ | Loc_known { loc = _; scopes } -> string_of_scopes scopes in
let event kind info =
{ ev_pos = 0; (* patched in emitcode *)
ev_module = !compunit_name;
- ev_loc = lev.lev_loc;
+ ev_loc = to_location lev.lev_loc;
ev_kind = kind;
+ ev_defname;
ev_info = info;
ev_typenv = Env.summary lev.lev_env;
ev_typsubst = Subst.identity;
let c = comp_expr env lam sz cont in
let ev = event Event_pseudo Event_other in
add_event ev c
- | Lev_after _ when is_tailcall cont -> (* don't destroy tail call opt *)
- comp_expr env lam sz cont
| Lev_after ty ->
- let info =
+ let preserve_tailcall =
match lam with
- Lapply{ap_args = args} -> Event_return (List.length args)
- | Lsend(_, _, _, args, _) -> Event_return (List.length args + 1)
- | _ -> Event_other
+ | Lprim(prim, _, _) -> preserve_tailcall_for_prim prim
+ | _ -> true
in
- let ev = event (Event_after ty) info in
- let cont1 = add_event ev cont in
- comp_expr env lam sz cont1
+ if preserve_tailcall && is_tailcall cont then
+ (* don't destroy tail call opt *)
+ comp_expr env lam sz cont
+ else begin
+ let info =
+ match lam with
+ Lapply{ap_args = args} -> Event_return (List.length args)
+ | Lsend(_, _, _, args, _) -> Event_return (List.length args + 1)
+ | Lprim(_,args,_) -> Event_return (List.length args)
+ | _ -> Event_other
+ in
+ let ev = event (Event_after ty) info in
+ let cont1 = add_event ev cont in
+ comp_expr env lam sz cont1
+ end
| Lev_module_definition _ ->
comp_expr env lam sz cont
end
then Consistbl.set crc_interfaces name crc file_name
else Consistbl.check crc_interfaces name crc file_name)
cu.cu_imports
- with Consistbl.Inconsistency(name, user, auth) ->
+ with Consistbl.Inconsistency {
+ unit_name = name;
+ inconsistent_source = user;
+ original_source = auth;
+ } ->
raise(Error(Inconsistent_import(name, user, auth)))
end;
begin try
[Printf.sprintf "-fdebug-prefix-map=%s=camlprim.c" prim_name]
else
[] in
+ let exitcode =
+ (Clflags.std_include_flag "-I" ^ " " ^ Config.bytecomp_c_libraries)
+ in
Ccomp.call_linker Ccomp.Exe exec_name
(debug_prefix_map @ [prim_name] @ List.rev !Clflags.ccobjs @ [runtime_lib])
- (Clflags.std_include_flag "-I" ^ " " ^ Config.bytecomp_c_libraries)
+ exitcode = 0
let append_bytecode bytecode_name exec_name =
let oc = open_out_gen [Open_wronly; Open_append; Open_binary] 0 exec_name in
else "-lcamlrun" ^ !Clflags.runtime_variant in
Ccomp.call_linker mode output_name
([obj_file] @ List.rev !Clflags.ccobjs @ [runtime_lib])
- c_libs
+ c_libs = 0
) then raise (Error Custom_runtime);
end
end;
ev_module: string; (* Name of defining module *)
ev_loc: Location.t; (* Location in source file *)
ev_kind: debug_event_kind; (* Before/after event *)
+ ev_defname: string; (* Enclosing definition *)
ev_info: debug_event_info; (* Extra information *)
ev_typenv: Env.summary; (* Typing environment *)
ev_typsubst: Subst.t; (* Substitution over types *)
(* Debugging events *)
-(* Warning: when you change these types, check runtime/backtrace.c *)
+(* Warning: when you change these types, check runtime/backtrace_byt.c *)
type debug_event =
{ mutable ev_pos: int; (* Position in bytecode *)
ev_module: string; (* Name of defining module *)
ev_loc: Location.t; (* Location in source file *)
ev_kind: debug_event_kind; (* Before/after event *)
+ ev_defname: string; (* Enclosing definition *)
ev_info: debug_event_info; (* Extra information *)
ev_typenv: Env.summary; (* Typing environment *)
ev_typsubst: Subst.t; (* Substitution over types *)
try List.assoc name Predef.builtin_values
with Not_found -> fatal_error "Symtable.init" in
let c = slot_for_setglobal id in
- let cst = Const_block(Obj.object_tag,
- [Const_base(Const_string (name, None));
- Const_base(Const_int (-i-1))
- ])
+ let cst = Const_block
+ (Obj.object_tag,
+ [Const_base(Const_string (name, Location.none,None));
+ Const_base(Const_int (-i-1))
+ ])
in
literal_table := (c, cst) :: !literal_table)
Runtimedef.builtin_exceptions;
let rec transl_const = function
Const_base(Const_int i) -> Obj.repr i
| Const_base(Const_char c) -> Obj.repr c
- | Const_base(Const_string (s, _)) -> Obj.repr s
+ | Const_base(Const_string (s, _, _)) -> Obj.repr s
| Const_base(Const_float f) -> Obj.repr (float_of_string f)
| Const_base(Const_int32 i) -> Obj.repr i
| Const_base(Const_int64 i) -> Obj.repr i
+++ /dev/null
-# This .gitignore is here to force git to create the compilerlibs directory
-# because git doesn't create empty directories.
-# The lines tell git to ignore everything in this directory except
-# the .gitignore file itself.
-
-*
-!.gitignore
--- /dev/null
+#**************************************************************************
+#* *
+#* OCaml *
+#* *
+#* Xavier Leroy, projet Cristal, INRIA Rocquencourt *
+#* *
+#* Copyright 1999 Institut National de Recherche en Informatique et *
+#* en Automatique. *
+#* *
+#* All rights reserved. This file is distributed under the terms of *
+#* the GNU Lesser General Public License version 2.1, with the *
+#* special exception on linking described in the file LICENSE. *
+#* *
+#**************************************************************************
+
+# Targets and dependencies for compilerlibs archives
+
+# This file is meant to be included from the root Makefile, not to be
+# executed directly (this is why it is not simply named Makefile).
+
+# For each group of compilation units, we have a variable GROUP with
+# only .cmo files, and a separate variable GROUP_CMI for .cmi files
+# corresponding to the .mli-only modules only. These .cmi are not
+# linked in the archive, but they are marked as dependencies to ensure
+# that they are consistent with the interface digests in the archives.
+
+UTILS=utils/config.cmo utils/build_path_prefix_map.cmo utils/misc.cmo \
+ utils/identifiable.cmo utils/numbers.cmo utils/arg_helper.cmo \
+ utils/clflags.cmo utils/profile.cmo utils/load_path.cmo \
+ utils/terminfo.cmo utils/ccomp.cmo utils/warnings.cmo \
+ utils/consistbl.cmo utils/strongly_connected_components.cmo \
+ utils/targetint.cmo utils/int_replace_polymorphic_compare.cmo \
+ utils/domainstate.cmo
+UTILS_CMI=
+
+PARSING=parsing/location.cmo parsing/longident.cmo \
+ parsing/docstrings.cmo parsing/syntaxerr.cmo \
+ parsing/ast_helper.cmo \
+ parsing/pprintast.cmo \
+ parsing/camlinternalMenhirLib.cmo parsing/parser.cmo \
+ parsing/lexer.cmo parsing/parse.cmo parsing/printast.cmo \
+ parsing/ast_mapper.cmo parsing/ast_iterator.cmo parsing/attr_helper.cmo \
+ parsing/builtin_attributes.cmo parsing/ast_invariants.cmo parsing/depend.cmo
+PARSING_CMI=\
+ parsing/asttypes.cmi \
+ parsing/parsetree.cmi
+
+TYPING=typing/ident.cmo typing/path.cmo \
+ typing/primitive.cmo typing/type_immediacy.cmo typing/types.cmo \
+ typing/btype.cmo typing/oprint.cmo \
+ typing/subst.cmo typing/predef.cmo \
+ typing/datarepr.cmo file_formats/cmi_format.cmo \
+ typing/persistent_env.cmo typing/env.cmo \
+ typing/typedtree.cmo typing/printtyped.cmo typing/ctype.cmo \
+ typing/printtyp.cmo typing/includeclass.cmo \
+ typing/mtype.cmo typing/envaux.cmo typing/includecore.cmo \
+ typing/tast_iterator.cmo typing/tast_mapper.cmo typing/stypes.cmo \
+ file_formats/cmt_format.cmo typing/cmt2annot.cmo typing/untypeast.cmo \
+ typing/includemod.cmo typing/typetexp.cmo typing/printpat.cmo \
+ typing/parmatch.cmo \
+ typing/typedecl_properties.cmo typing/typedecl_variance.cmo \
+ typing/typedecl_unboxed.cmo typing/typedecl_immediacy.cmo \
+ typing/typedecl_separability.cmo \
+ typing/typedecl.cmo typing/typeopt.cmo \
+ typing/rec_check.cmo typing/typecore.cmo typing/typeclass.cmo \
+ typing/typemod.cmo
+TYPING_CMI=\
+ typing/annot.cmi \
+ typing/outcometree.cmi
+
+LAMBDA=lambda/debuginfo.cmo \
+ lambda/lambda.cmo lambda/printlambda.cmo \
+ lambda/switch.cmo lambda/matching.cmo \
+ lambda/translobj.cmo lambda/translattribute.cmo \
+ lambda/translprim.cmo lambda/translcore.cmo \
+ lambda/translclass.cmo lambda/translmod.cmo \
+ lambda/simplif.cmo lambda/runtimedef.cmo
+LAMBDA_CMI=
+
+COMP=\
+ bytecomp/meta.cmo bytecomp/opcodes.cmo \
+ bytecomp/bytesections.cmo bytecomp/dll.cmo \
+ bytecomp/symtable.cmo \
+ driver/pparse.cmo driver/compenv.cmo \
+ driver/main_args.cmo driver/compmisc.cmo \
+ driver/makedepend.cmo \
+ driver/compile_common.cmo
+COMP_CMI=\
+ file_formats/cmo_format.cmi \
+ file_formats/cmx_format.cmi \
+ file_formats/cmxs_format.cmi
+# All file format descriptions (including cmx{,s}) are in the
+# ocamlcommon library so that ocamlobjinfo can depend on them.
+
+COMMON_CMI=$(UTILS_CMI) $(PARSING_CMI) $(TYPING_CMI) $(LAMBDA_CMI) $(COMP_CMI)
+
+COMMON=$(UTILS) $(PARSING) $(TYPING) $(LAMBDA) $(COMP)
+
+BYTECOMP=bytecomp/instruct.cmo bytecomp/bytegen.cmo \
+ bytecomp/printinstr.cmo bytecomp/emitcode.cmo \
+ bytecomp/bytelink.cmo bytecomp/bytelibrarian.cmo bytecomp/bytepackager.cmo \
+ driver/errors.cmo driver/compile.cmo
+BYTECOMP_CMI=
+
+ARCH_SPECIFIC =\
+ asmcomp/arch.ml asmcomp/proc.ml asmcomp/CSE.ml asmcomp/selection.ml \
+ asmcomp/scheduling.ml asmcomp/reload.ml
+ARCH_SPECIFIC_CMI=
+
+INTEL_ASM=\
+ asmcomp/x86_proc.cmo \
+ asmcomp/x86_dsl.cmo \
+ asmcomp/x86_gas.cmo \
+ asmcomp/x86_masm.cmo
+INTEL_ASM_CMI=\
+ asmcomp/x86_ast.cmi
+
+ARCH_SPECIFIC_ASMCOMP=
+ifeq ($(ARCH),i386)
+ARCH_SPECIFIC_ASMCOMP=$(INTEL_ASM)
+ARCH_SPECIFIC_ASMCOMP_CMI=$(INTEL_ASM_CMI)
+endif
+ifeq ($(ARCH),amd64)
+ARCH_SPECIFIC_ASMCOMP=$(INTEL_ASM)
+ARCH_SPECIFIC_ASMCOMP_CMI=$(INTEL_ASM_CMI)
+endif
+
+ASMCOMP=\
+ $(ARCH_SPECIFIC_ASMCOMP) \
+ asmcomp/arch.cmo \
+ asmcomp/cmm.cmo asmcomp/printcmm.cmo \
+ asmcomp/reg.cmo asmcomp/debug/reg_with_debug_info.cmo \
+ asmcomp/debug/reg_availability_set.cmo \
+ asmcomp/mach.cmo asmcomp/proc.cmo \
+ asmcomp/afl_instrument.cmo \
+ asmcomp/strmatch.cmo \
+ asmcomp/cmmgen_state.cmo \
+ asmcomp/cmm_helpers.cmo \
+ asmcomp/cmmgen.cmo \
+ asmcomp/interval.cmo \
+ asmcomp/printmach.cmo asmcomp/selectgen.cmo \
+ asmcomp/spacetime_profiling.cmo asmcomp/selection.cmo \
+ asmcomp/comballoc.cmo \
+ asmcomp/CSEgen.cmo asmcomp/CSE.cmo \
+ asmcomp/liveness.cmo \
+ asmcomp/spill.cmo asmcomp/split.cmo \
+ asmcomp/interf.cmo asmcomp/coloring.cmo \
+ asmcomp/linscan.cmo \
+ asmcomp/reloadgen.cmo asmcomp/reload.cmo \
+ asmcomp/deadcode.cmo \
+ asmcomp/linear.cmo asmcomp/printlinear.cmo asmcomp/linearize.cmo \
+ asmcomp/debug/available_regs.cmo \
+ asmcomp/debug/compute_ranges_intf.cmo \
+ asmcomp/debug/compute_ranges.cmo \
+ asmcomp/schedgen.cmo asmcomp/scheduling.cmo \
+ asmcomp/branch_relaxation_intf.cmo \
+ asmcomp/branch_relaxation.cmo \
+ asmcomp/emitaux.cmo asmcomp/emit.cmo asmcomp/asmgen.cmo \
+ asmcomp/asmlink.cmo asmcomp/asmlibrarian.cmo asmcomp/asmpackager.cmo \
+ driver/opterrors.cmo driver/optcompile.cmo
+ASMCOMP_CMI=$(ARCH_SPECIFIC_ASMCOMP_CMI)
+
+# Files under middle_end/ are not to reference files under asmcomp/.
+# This ensures that the middle end can be linked (e.g. for objinfo) even when
+# the native code compiler is not present for some particular target.
+
+MIDDLE_END_CLOSURE=\
+ middle_end/closure/closure.cmo \
+ middle_end/closure/closure_middle_end.cmo
+MIDDLE_END_CLOSURE_CMI=
+
+# Owing to dependencies through [Compilenv], which would be
+# difficult to remove, some of the lower parts of Flambda (anything that is
+# saved in a .cmx file) have to be included in the [MIDDLE_END] stanza, below.
+MIDDLE_END_FLAMBDA=\
+ middle_end/flambda/import_approx.cmo \
+ middle_end/flambda/lift_code.cmo \
+ middle_end/flambda/closure_conversion_aux.cmo \
+ middle_end/flambda/closure_conversion.cmo \
+ middle_end/flambda/initialize_symbol_to_let_symbol.cmo \
+ middle_end/flambda/lift_let_to_initialize_symbol.cmo \
+ middle_end/flambda/find_recursive_functions.cmo \
+ middle_end/flambda/invariant_params.cmo \
+ middle_end/flambda/inconstant_idents.cmo \
+ middle_end/flambda/alias_analysis.cmo \
+ middle_end/flambda/lift_constants.cmo \
+ middle_end/flambda/share_constants.cmo \
+ middle_end/flambda/simplify_common.cmo \
+ middle_end/flambda/remove_unused_arguments.cmo \
+ middle_end/flambda/remove_unused_closure_vars.cmo \
+ middle_end/flambda/remove_unused_program_constructs.cmo \
+ middle_end/flambda/simplify_boxed_integer_ops.cmo \
+ middle_end/flambda/simplify_primitives.cmo \
+ middle_end/flambda/inlining_stats_types.cmo \
+ middle_end/flambda/inlining_stats.cmo \
+ middle_end/flambda/inline_and_simplify_aux.cmo \
+ middle_end/flambda/remove_free_vars_equal_to_args.cmo \
+ middle_end/flambda/extract_projections.cmo \
+ middle_end/flambda/augment_specialised_args.cmo \
+ middle_end/flambda/unbox_free_vars_of_closures.cmo \
+ middle_end/flambda/unbox_specialised_args.cmo \
+ middle_end/flambda/unbox_closures.cmo \
+ middle_end/flambda/inlining_transforms.cmo \
+ middle_end/flambda/inlining_decision.cmo \
+ middle_end/flambda/inline_and_simplify.cmo \
+ middle_end/flambda/ref_to_variables.cmo \
+ middle_end/flambda/flambda_invariants.cmo \
+ middle_end/flambda/traverse_for_exported_symbols.cmo \
+ middle_end/flambda/build_export_info.cmo \
+ middle_end/flambda/closure_offsets.cmo \
+ middle_end/flambda/un_anf.cmo \
+ middle_end/flambda/flambda_to_clambda.cmo \
+ middle_end/flambda/flambda_middle_end.cmo
+MIDDLE_END_FLAMBDA_CMI=\
+ middle_end/flambda/inlining_decision_intf.cmi \
+ middle_end/flambda/simplify_boxed_integer_ops_intf.cmi
+
+MIDDLE_END=\
+ middle_end/internal_variable_names.cmo \
+ middle_end/linkage_name.cmo \
+ middle_end/compilation_unit.cmo \
+ middle_end/variable.cmo \
+ middle_end/flambda/base_types/closure_element.cmo \
+ middle_end/flambda/base_types/closure_id.cmo \
+ middle_end/symbol.cmo \
+ middle_end/backend_var.cmo \
+ middle_end/clambda_primitives.cmo \
+ middle_end/printclambda_primitives.cmo \
+ middle_end/clambda.cmo \
+ middle_end/printclambda.cmo \
+ middle_end/semantics_of_primitives.cmo \
+ middle_end/convert_primitives.cmo \
+ middle_end/flambda/base_types/id_types.cmo \
+ middle_end/flambda/base_types/export_id.cmo \
+ middle_end/flambda/base_types/tag.cmo \
+ middle_end/flambda/base_types/mutable_variable.cmo \
+ middle_end/flambda/base_types/set_of_closures_id.cmo \
+ middle_end/flambda/base_types/set_of_closures_origin.cmo \
+ middle_end/flambda/base_types/closure_origin.cmo \
+ middle_end/flambda/base_types/var_within_closure.cmo \
+ middle_end/flambda/base_types/static_exception.cmo \
+ middle_end/flambda/pass_wrapper.cmo \
+ middle_end/flambda/allocated_const.cmo \
+ middle_end/flambda/parameter.cmo \
+ middle_end/flambda/projection.cmo \
+ middle_end/flambda/flambda.cmo \
+ middle_end/flambda/flambda_iterators.cmo \
+ middle_end/flambda/flambda_utils.cmo \
+ middle_end/flambda/freshening.cmo \
+ middle_end/flambda/effect_analysis.cmo \
+ middle_end/flambda/inlining_cost.cmo \
+ middle_end/flambda/simple_value_approx.cmo \
+ middle_end/flambda/export_info.cmo \
+ middle_end/flambda/export_info_for_pack.cmo \
+ middle_end/compilenv.cmo \
+ $(MIDDLE_END_CLOSURE) \
+ $(MIDDLE_END_FLAMBDA)
+MIDDLE_END_CMI=\
+ middle_end/backend_intf.cmi \
+ $(MIDDLE_END_CLOSURE_CMI) \
+ $(MIDDLE_END_FLAMBDA_CMI)
+
+OPTCOMP=$(MIDDLE_END) $(ASMCOMP)
+OPTCOMP_CMI=$(MIDDLE_END_CMI) $(ASMCOMP_CMI)
+
+TOPLEVEL=toplevel/genprintval.cmo toplevel/toploop.cmo \
+ toplevel/trace.cmo toplevel/topdirs.cmo toplevel/topmain.cmo
+TOPLEVEL_CMI=
+
+OPTTOPLEVEL=toplevel/genprintval.cmo toplevel/opttoploop.cmo \
+ toplevel/opttopdirs.cmo toplevel/opttopmain.cmo
+OPTTOPLEVEL_CMI=
+
+
+$(COMMON:.cmo=.cmx) $(BYTECOMP:.cmo=.cmx) $(OPTCOMP:.cmo=.cmx): ocamlopt
+$(OPTTOPLEVEL:.cmo=.cmx): ocamlopt
+
+
+compilerlibs/ocamlcommon.cma: $(COMMON_CMI) $(COMMON)
+ $(CAMLC) -a -linkall -o $@ $(COMMON)
+partialclean::
+ rm -f compilerlibs/ocamlcommon.cma
+
+compilerlibs/ocamlcommon.cmxa: $(COMMON_CMI) $(COMMON:.cmo=.cmx)
+ $(CAMLOPT) -a -linkall -o $@ $(COMMON:.cmo=.cmx)
+partialclean::
+ rm -f compilerlibs/ocamlcommon.cmxa \
+ compilerlibs/ocamlcommon.a compilerlibs/ocamlcommon.lib
+
+
+compilerlibs/ocamlbytecomp.cma: $(BYTECOMP_CMI) $(BYTECOMP)
+ $(CAMLC) -a -o $@ $(BYTECOMP)
+partialclean::
+ rm -f compilerlibs/ocamlbytecomp.cma
+
+compilerlibs/ocamlbytecomp.cmxa: $(BYTECOMP_CMI) $(BYTECOMP:.cmo=.cmx)
+ $(CAMLOPT) -a $(OCAML_NATDYNLINKOPTS) -o $@ $(BYTECOMP:.cmo=.cmx)
+partialclean::
+ rm -f compilerlibs/ocamlbytecomp.cmxa \
+ compilerlibs/ocamlbytecomp.a compilerlibs/ocamlbytecomp.lib
+
+
+compilerlibs/ocamlmiddleend.cma: $(MIDDLE_END_CMI) $(MIDDLE_END)
+ $(CAMLC) -a -o $@ $(MIDDLE_END)
+compilerlibs/ocamlmiddleend.cmxa: $(MIDDLE_END_CMI) $(MIDDLE_END:%.cmo=%.cmx)
+ $(CAMLOPT) -a -o $@ $(MIDDLE_END:%.cmo=%.cmx)
+partialclean::
+ rm -f compilerlibs/ocamlmiddleend.cma \
+ compilerlibs/ocamlmiddleend.cmxa \
+ compilerlibs/ocamlmiddleend.a \
+ compilerlibs/ocamlmiddleend.lib
+
+
+compilerlibs/ocamloptcomp.cma: $(OPTCOMP_CMI) $(OPTCOMP)
+ $(CAMLC) -a -o $@ $(OPTCOMP)
+partialclean::
+ rm -f compilerlibs/ocamloptcomp.cma
+
+compilerlibs/ocamloptcomp.cmxa: $(OPTCOMP_CMI) $(OPTCOMP:.cmo=.cmx)
+ $(CAMLOPT) -a -o $@ $(OPTCOMP:.cmo=.cmx)
+partialclean::
+ rm -f compilerlibs/ocamloptcomp.cmxa \
+ compilerlibs/ocamloptcomp.a compilerlibs/ocamloptcomp.lib
+
+
+compilerlibs/ocamltoplevel.cma: $(TOPLEVEL_CMI) $(TOPLEVEL)
+ $(CAMLC) -a -o $@ $(TOPLEVEL)
+partialclean::
+ rm -f compilerlibs/ocamltoplevel.cma
+
+compilerlibs/ocamlopttoplevel.cmxa: $(OPTTOPLEVEL_CMI) $(OPTTOPLEVEL:.cmo=.cmx)
+ $(CAMLOPT) -a -o $@ $(OPTTOPLEVEL:.cmo=.cmx)
+partialclean::
+ rm -f compilerlibs/ocamlopttoplevel.cmxa \
+ compilerlibs/ocamlopttoplevel.a compilerlibs/ocamlopttoplevel.lib
fi
fi
# Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69 for OCaml 4.10.1.
+# Generated by GNU Autoconf 2.69 for OCaml 4.11.0.
#
# Report bugs to <caml-list@inria.fr>.
#
# Identity of this package.
PACKAGE_NAME='OCaml'
PACKAGE_TARNAME='ocaml'
-PACKAGE_VERSION='4.10.1'
-PACKAGE_STRING='OCaml 4.10.1'
+PACKAGE_VERSION='4.11.0'
+PACKAGE_STRING='OCaml 4.11.0'
PACKAGE_BUGREPORT='caml-list@inria.fr'
PACKAGE_URL='http://www.ocaml.org'
sharedlib_cflags
asm_cfi_supported
AS
+endianness
ASPP
bfd_ldlibs
bfd_ldflags
x_libraries
x_includes
pthread_link
+ocamltest
ocamldoc
with_camltex
with_debugger
as_has_debug_prefix_map
cc_has_debug_prefix_map
otherlibraries
+has_monotonic_clock
instrumented_runtime
debug_runtime
cmxs
shebangscripts
long_shebang
iflexdir
-ocamlopt_cppflags
-ocamlopt_cflags
ocamlc_cppflags
ocamlc_cflags
nativecclibs
enable_unix_lib
enable_bigarray_lib
enable_ocamldoc
+enable_ocamltest
enable_frame_pointers
enable_naked_pointers
enable_spacetime
# Omit some internal or obsolete options to make the list less imposing.
# This message is too long to be a string in the A/UX 3.1 sh.
cat <<_ACEOF
-\`configure' configures OCaml 4.10.1 to adapt to many kinds of systems.
+\`configure' configures OCaml 4.11.0 to adapt to many kinds of systems.
Usage: $0 [OPTION]... [VAR=VALUE]...
if test -n "$ac_init_help"; then
case $ac_init_help in
- short | recursive ) echo "Configuration of OCaml 4.10.1:";;
+ short | recursive ) echo "Configuration of OCaml 4.11.0:";;
esac
cat <<\_ACEOF
--disable-unix-lib do not build the unix library
--disable-bigarray-lib do not build the legacy separate bigarray library
--disable-ocamldoc do not build the ocamldoc documentation system
+ --disable-ocamltest do not build the ocamltest driver
--enable-frame-pointers use frame pointers in runtime and generated code
--disable-naked-pointers
do not allow naked pointers
test -n "$ac_init_help" && exit $ac_status
if $ac_init_version; then
cat <<\_ACEOF
-OCaml configure 4.10.1
+OCaml configure 4.11.0
generated by GNU Autoconf 2.69
Copyright (C) 2012 Free Software Foundation, Inc.
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
-It was created by OCaml $as_me 4.10.1, which was
+It was created by OCaml $as_me 4.11.0, which was
generated by GNU Autoconf 2.69. Invocation command line was
$ $0 $@
-{ $as_echo "$as_me:${as_lineno-$LINENO}: Configuring OCaml version 4.10.1" >&5
-$as_echo "$as_me: Configuring OCaml version 4.10.1" >&6;}
+{ $as_echo "$as_me:${as_lineno-$LINENO}: Configuring OCaml version 4.11.0" >&5
+$as_echo "$as_me: Configuring OCaml version 4.11.0" >&6;}
# Configuration variables
internal_cppflags=""
ocamlc_cflags=""
ocamlc_cppflags=""
-ocamlopt_cflags=""
-ocamlopt_cppflags=""
oc_ldflags=""
with_sharedlibs=true
ostype="Unix"
profinfo=false
profinfo_width=0
extralibs=
+instrumented_runtime=false
+instrumented_runtime_ldlibs=""
# Information about the package
-VERSION=4.10.1
+VERSION=4.11.0
# Note: This is present for the flexdll bootstrap where it exposed as the old
-
# TODO: rename this variable
+
+
ac_config_files="$ac_config_files Makefile.config"
+ac_config_files="$ac_config_files tools/eventlog_metadata"
+
ac_config_headers="$ac_config_headers runtime/caml/m.h"
ac_config_headers="$ac_config_headers runtime/caml/s.h"
fi
+# Check whether --enable-ocamltest was given.
+if test "${enable_ocamltest+set}" = set; then :
+ enableval=$enable_ocamltest;
+fi
+
+
# Check whether --enable-frame-pointers was given.
if test "${enable_frame_pointers+set}" = set; then :
enableval=$enable_frame_pointers;
msvc-*) :
outputobj=-Fo; gcc_warnings="" ;; #(
*) :
- outputobj='-o $(EMPTY)'; case 4.10.1 in #(
+ outputobj='-o $(EMPTY)'
+ gcc_warnings='-Wall -Wdeclaration-after-statement'
+ case 4.11.0 in #(
*+dev*) :
- gcc_warnings="-Wall -Werror" ;; #(
+ gcc_warnings="$gcc_warnings -Werror" ;; #(
*) :
- gcc_warnings="-Wall"
- ;;
+ ;;
esac
- ;;
+ ;;
esac
# We select high optimization levels, provided we can turn off:
# in the macro itself, too
case $host in #(
*-*-mingw32) :
- internal_cflags="-Wno-unused $gcc_warnings"
- # TODO: see whether the code can be fixed to avoid -Wno-unused
- common_cflags="-O -mms-bitfields"
- internal_cppflags='-DUNICODE -D_UNICODE'
- internal_cppflags="$internal_cppflags -DWINDOWS_UNICODE="
- internal_cppflags="${internal_cppflags}\$(WINDOWS_UNICODE)" ;; #(
+ case $ocaml_cv_cc_vendor in #(
+ gcc-[01234]-*) :
+ as_fn_error $? "This version of Mingw GCC is too old. Please use GCC version 5 or above." "$LINENO" 5 ;; #(
+ gcc-*) :
+ internal_cflags="-Wno-unused $gcc_warnings \
+-fexcess-precision=standard"
+ # TODO: see whether the code can be fixed to avoid -Wno-unused
+ common_cflags="-O2 -fno-strict-aliasing -fwrapv -mms-bitfields"
+ internal_cppflags='-DUNICODE -D_UNICODE'
+ internal_cppflags="$internal_cppflags -DWINDOWS_UNICODE="
+ internal_cppflags="${internal_cppflags}\$(WINDOWS_UNICODE)" ;; #(
+ *) :
+ as_fn_error $? "Unsupported C compiler for a Mingw build" "$LINENO" 5 ;;
+esac ;; #(
*) :
case $ocaml_cv_cc_vendor in #(
clang-*) :
common_cflags="-O2 -fno-strict-aliasing -fwrapv";
internal_cflags="$gcc_warnings -fno-common" ;; #(
- gcc-012-*) :
+ gcc-[012]-*) :
# Some versions known to miscompile OCaml, e,g, 2.7.2.1, some 2.96.
# Plus: C99 support unknown.
- as_fn_error $? "This version of GCC is too old.
- Please use GCC version 4.2 or above." "$LINENO" 5 ;; #(
- gcc-3-*|gcc-4-01) :
+ as_fn_error $? "This version of GCC is too old. Please use GCC version 4.2 or above." "$LINENO" 5 ;; #(
+ gcc-3-*|gcc-4-[01]) :
# No -fwrapv option before GCC 3.4.
# Known problems with -fwrapv fixed in 4.2 only.
- { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This version of GCC is rather old.
- Reducing optimization level.\"" >&5
-$as_echo "$as_me: WARNING: This version of GCC is rather old.
- Reducing optimization level.\"" >&2;};
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This version of GCC is rather old. Reducing optimization level.\"" >&5
+$as_echo "$as_me: WARNING: This version of GCC is rather old. Reducing optimization level.\"" >&2;};
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Consider using GCC version 4.2 or above." >&5
$as_echo "$as_me: WARNING: Consider using GCC version 4.2 or above." >&2;};
common_cflags="-std=gnu99 -O";
internal_cflags="$gcc_warnings" ;; #(
+ gcc-4-[234]) :
+ # No -fexcess-precision option before GCC 4.5
+ common_cflags="-std=gnu99 -O2 -fno-strict-aliasing -fwrapv \
+-fno-builtin-memcmp";
+ internal_cflags="$gcc_warnings" ;; #(
gcc-4-*) :
common_cflags="-std=gnu99 -O2 -fno-strict-aliasing -fwrapv \
-fno-builtin-memcmp";
- internal_cflags="$gcc_warnings" ;; #(
+ internal_cflags="$gcc_warnings -fexcess-precision=standard" ;; #(
gcc-*) :
common_cflags="-O2 -fno-strict-aliasing -fwrapv";
- internal_cflags="$gcc_warnings -fno-common" ;; #(
+ internal_cflags="$gcc_warnings -fno-common \
+-fexcess-precision=standard" ;; #(
msvc-*) :
common_cflags="-nologo -O2 -Gy- -MD"
common_cppflags="-D_CRT_SECURE_NO_DEPRECATE"
$as_echo "$ac_cv_c_bigendian" >&6; }
case $ac_cv_c_bigendian in #(
yes)
- $as_echo "#define ARCH_BIG_ENDIAN 1" >>confdefs.h
-;; #(
+
+ $as_echo "#define ARCH_BIG_ENDIAN 1" >>confdefs.h
+,
+ endianness="be"
+ ;; #(
no)
- ;; #(
+ endianness="le" ;; #(
universal)
as_fn_error $? "unable to handle universal endianness" "$LINENO" 5
_ACEOF
+# The cast to long int works around a bug in the HP C Compiler,
+# see AC_CHECK_SIZEOF for more information.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking alignment of long long" >&5
+$as_echo_n "checking alignment of long long... " >&6; }
+if ${ac_cv_alignof_long_long+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if ac_fn_c_compute_int "$LINENO" "(long int) offsetof (ac__type_alignof_, y)" "ac_cv_alignof_long_long" "$ac_includes_default
+#ifndef offsetof
+# define offsetof(type, member) ((char *) &((type *) 0)->member - (char *) 0)
+#endif
+typedef struct { char x; long long y; } ac__type_alignof_;"; then :
+
+else
+ if test "$ac_cv_type_long_long" = yes; then
+ { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "cannot compute alignment of long long
+See \`config.log' for more details" "$LINENO" 5; }
+ else
+ ac_cv_alignof_long_long=0
+ fi
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_alignof_long_long" >&5
+$as_echo "$ac_cv_alignof_long_long" >&6; }
+
+
+
+cat >>confdefs.h <<_ACEOF
+#define ALIGNOF_LONG_LONG $ac_cv_alignof_long_long
+_ACEOF
+
+
if ! $arch64; then :
case $target_cpu in #(
$as_echo "#define ARCH_ALIGN_DOUBLE 1" >>confdefs.h
fi
- if test "$ac_cv_alignof_long" -gt 4; then :
- $as_echo "#define ARCH_ALIGN_LONG 1" >>confdefs.h
+ if test "x$ac_cv_sizeof_long" = "x8" &&
+ test "$ac_cv_alignof_long" -gt 4; then :
+ $as_echo "#define ARCH_ALIGN_INT64 1" >>confdefs.h
+else
+ if test "x$ac_cv_sizeof_long_long" = "x8" &&
+ test "$ac_cv_alignof_long_long" -gt 4; then :
+ $as_echo "#define ARCH_ALIGN_INT64 1" >>confdefs.h
+
+fi
fi
;;
esac
natdynlink=true ;; #(
aarch64-*-freebsd*) :
natdynlink=true ;; #(
+ riscv*-*-linux*) :
+ natdynlink=true ;; #(
*) :
;;
esac
aarch64-*-freebsd*) :
arch=arm64; system=freebsd ;; #(
x86_64-*-cygwin*) :
- arch=amd64; system=cygwin
+ arch=amd64; system=cygwin ;; #(
+ riscv64-*-linux*) :
+ arch=riscv; model=riscv64; system=linux
;; #(
*) :
;;
otherlibraries="$otherlibraries raw_spacetime_lib"
fi
+# Disable PIE at link time when ocamlopt does not produce position-independent
+# code and the system produces PIE executables by default and demands PIC
+# object files to do so.
+# This issue does not affect amd64 (x86_64) and s390x (Z systems),
+# since ocamlopt produces PIC object files by default.
+# Currently the problem is known for Alpine Linux on platforms other
+# than amd64 and s390x (issue #7562), and probably affects all Linux
+# distributions that use the musl standard library and dynamic loader.
+# Other systems have PIE by default but can cope with non-PIC object files,
+# e.g. Ubuntu >= 17.10 for i386, which uses the glibc dynamic loader.
+
+case $arch in #(
+ amd64|s390x|none) :
+ # ocamlopt generates PIC code or doesn't generate code at all
+ ;; #(
+ *) :
+ case $host in #(
+ *-linux-musl) :
+ # Alpine and other musl-based Linux distributions
+ common_cflags="-no-pie $common_cflags" ;; #(
+ *) :
+ ;;
+esac ;;
+esac
+
# Assembler
if test -n "$host_alias"; then :
*,dragonfly) :
default_as="${toolpref}as"
default_aspp="${toolpref}cc -c" ;; #(
- amd64,*|arm,*|arm64,*|i386,*) :
+ amd64,*|arm,*|arm64,*|i386,*|riscv,*) :
case $ocaml_cv_cc_vendor in #(
clang-*) :
default_as="${toolpref}clang -c -Wno-trigraphs"
fi
-## clock_gettime, for the instrumented runtime
+## Checking for monotonic clock source
+## On Windows MSVC, QueryPerformanceCounter and QueryPerformanceFrequency
+## are always available.
+## On Unix platforms, we check for the appropriate POSIX feature-test macros.
+## On MacOS clock_gettime's CLOCK_MONOTONIC flag is not actually monotonic.
+## mach_timebase_info and mach_absolute_time are used instead.
-## Note: on MinGW, configure finds a clock_gettime and thus the build
-# system tries to build the instrumented runtime, which causes
-# warnings. For the moment we simply disable it on MinGW
-# but this would need to be further investigated
case $host in #(
- *-*-mingw32) :
- instrumented_runtime=false ;; #(
+ *-*-windows) :
+ has_monotonic_clock=true ;; #(
+ *-apple-darwin*) :
+
+ for ac_func in mach_timebase_info mach_absolute_time
+do :
+ as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
+ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
+if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
+ cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+ has_monotonic_clock=true
+ $as_echo "#define HAS_MACH_ABSOLUTE_TIME 1" >>confdefs.h
+
+
+else
+ has_monotonic_clock=false
+fi
+done
+ ;; #(
*) :
- if test "x$enable_instrumented_runtime" = "xno" ; then :
- instrumented_runtime=false; instrumented_runtime_libs=""
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+ #include <unistd.h>
+ #include <time.h>
+ int main(void)
+ {
+ #if !(defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK) \
+ && _POSIX_MONOTONIC_CLOCK != (-1))
+ #error "no monotonic clock source"
+ #endif
+ return 0;
+ }
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+ has_monotonic_clock=true
+ $as_echo "#define HAS_POSIX_MONOTONIC_CLOCK 1" >>confdefs.h
+
+
else
+ has_monotonic_clock=false
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing clock_gettime" >&5
+ ;;
+esac
+
+# The instrumented runtime is built by default
+# if the proper clock source is found.
+# If asked via --enable-instrumented-runtime, configuration fails if the proper
+# clock source is missing.
+if test "x$enable_instrumented_runtime" != "xno" ; then :
+
+ case $host in #(
+ *-*-windows) :
+ instrumented_runtime=true ;; #(
+ *-apple-darwin*) :
+
+ case $enable_instrumented_runtime,$has_monotonic_clock in #(
+ *,true) :
+ instrumented_runtime=true ;; #(
+ yes,false) :
+
+ as_fn_error $? "Instrumented runtime support requested \
+but no proper monotonic clock source was found." "$LINENO" 5
+ ;; #(
+ auto,false) :
+ instrumented_runtime=false
+ ;; #(
+ *) :
+ ;;
+esac ;; #(
+ *) :
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing clock_gettime" >&5
$as_echo_n "checking for library containing clock_gettime... " >&6; }
if ${ac_cv_search_clock_gettime+:} false; then :
$as_echo_n "(cached) " >&6
has_clock_gettime=false
fi
- case $enable_instrumented_runtime,$has_clock_gettime in #(
- *,true) :
- instrumented_runtime=true
- if test "x$ac_cv_search_clock_gettime" = "xnone required"; then :
- instrumented_runtime_libs=""
-else
- instrumented_runtime_libs=$ac_cv_search_clock_gettime
-fi ;; #(
- auto,*) :
+ case $enable_instrumented_runtime,$has_clock_gettime,$has_monotonic_clock in #(
+ auto,false,*) :
+ instrumented_runtime=false ;; #(
+ auto,*,false) :
instrumented_runtime=false ;; #(
- yes,*) :
- as_fn_error $? "the instrumented runtime can not be built" "$LINENO" 5 ;; #(
+ *,true,true) :
+
+ instrumented_runtime=true
+ if test "x$ac_cv_search_clock_gettime" = "xnone required"; then :
+ instrumented_runtime_ldlibs=""
+else
+ instrumented_runtime_ldlibs=$ac_cv_search_clock_gettime
+
+fi
+ ;; #(
+ yes,false,*) :
+
+ as_fn_error $? "Instrumented runtime support requested \
+but clock_gettime is missing." "$LINENO" 5
+ ;; #(
+ yes,*,false) :
+
+ as_fn_error $? "Instrumented runtime support requested \
+but no proper monotonic clock source was found." "$LINENO" 5
+
+ ;; #(
*) :
;;
esac
-fi ;;
+ ;;
esac
+fi
+
## Sockets
## TODO: check whether the different libraries are really useful
*-*-mingw32|*-pc-windows) :
cclibs="$cclibs -lws2_32"
sockets=true ;; #(
+ *-*-haiku) :
+ cclibs="$cclibs -lnetwork"
+ sockets=true ;; #(
*) :
ac_fn_c_check_func "$LINENO" "socket" "ac_cv_func_socket"
fi
+## setenv and unsetenv
+
+ac_fn_c_check_func "$LINENO" "setenv" "ac_cv_func_setenv"
+if test "x$ac_cv_func_setenv" = xyes; then :
+ ac_fn_c_check_func "$LINENO" "unsetenv" "ac_cv_func_unsetenv"
+if test "x$ac_cv_func_unsetenv" = xyes; then :
+ $as_echo "#define HAS_SETENV_UNSETENV 1" >>confdefs.h
+
+fi
+
+fi
+
+
## newlocale() and <locale.h>
# Note: the detection fails on msvc so we hardcode the result
# (should be debugged later)
ocamldoc=ocamldoc
fi
+case $enable_ocamltest,4.11.0 in #(
+ yes,*|,*+dev*) :
+ ocamltest='ocamltest' ;; #(
+ *) :
+ ocamltest='' ;;
+esac
+
if test x"$enable_flambda" = "xyes"; then :
flambda=true
if test x"$enable_flambda_invariants" = "xyes"; then :
oc_cppflags="$common_cppflags $internal_cppflags"
ocamlc_cflags="$common_cflags $sharedlib_cflags"
ocamlc_cppflags="$common_cppflags"
-ocamlopt_cflags="$common_cflags"
-ocamlopt_cppflags="$common_cppflags"
cclibs="$cclibs $mathlib"
case $host in #(
bytecclibs="advapi32.lib ws2_32.lib version.lib"
nativecclibs="advapi32.lib ws2_32.lib version.lib" ;; #(
*) :
- bytecclibs="$cclibs $DLLIBS $pthread_link $instrumented_runtime_libs"
+ bytecclibs="$cclibs $DLLIBS $pthread_link $instrumented_runtime_ldlibs"
nativecclibs="$cclibs $DLLIBS" ;;
esac
# report actual input values of CONFIG_FILES etc. instead of their
# values after options handling.
ac_log="
-This file was extended by OCaml $as_me 4.10.1, which was
+This file was extended by OCaml $as_me 4.11.0, which was
generated by GNU Autoconf 2.69. Invocation command line was
CONFIG_FILES = $CONFIG_FILES
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
ac_cs_version="\\
-OCaml config.status 4.10.1
+OCaml config.status 4.11.0
configured by $0, generated by GNU Autoconf 2.69,
with options \\"\$ac_cs_config\\"
case $ac_config_target in
"Makefile.common") CONFIG_FILES="$CONFIG_FILES Makefile.common" ;;
"Makefile.config") CONFIG_FILES="$CONFIG_FILES Makefile.config" ;;
+ "tools/eventlog_metadata") CONFIG_FILES="$CONFIG_FILES tools/eventlog_metadata" ;;
"runtime/caml/m.h") CONFIG_HEADERS="$CONFIG_HEADERS runtime/caml/m.h" ;;
"runtime/caml/s.h") CONFIG_HEADERS="$CONFIG_HEADERS runtime/caml/s.h" ;;
"libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;;
internal_cppflags=""
ocamlc_cflags=""
ocamlc_cppflags=""
-ocamlopt_cflags=""
-ocamlopt_cppflags=""
oc_ldflags=""
with_sharedlibs=true
ostype="Unix"
profinfo=false
profinfo_width=0
extralibs=
+instrumented_runtime=false
+instrumented_runtime_ldlibs=""
# Information about the package
AC_SUBST([nativecclibs])
AC_SUBST([ocamlc_cflags])
AC_SUBST([ocamlc_cppflags])
-AC_SUBST([ocamlopt_cflags])
-AC_SUBST([ocamlopt_cppflags])
AC_SUBST([iflexdir])
AC_SUBST([long_shebang])
AC_SUBST([shebangscripts])
AC_SUBST([cmxs])
AC_SUBST([debug_runtime])
AC_SUBST([instrumented_runtime])
+AC_SUBST([has_monotonic_clock])
AC_SUBST([otherlibraries])
AC_SUBST([cc_has_debug_prefix_map])
AC_SUBST([as_has_debug_prefix_map])
AC_SUBST([with_debugger]) # TODO: rename this variable
AC_SUBST([with_camltex])
AC_SUBST([ocamldoc])
+AC_SUBST([ocamltest])
AC_SUBST([pthread_link])
AC_SUBST([x_includes])
AC_SUBST([x_libraries])
AC_SUBST([bfd_ldflags])
AC_SUBST([bfd_ldlibs])
AC_SUBST([ASPP])
+AC_SUBST([endianness])
AC_SUBST([AS])
AC_SUBST([asm_cfi_supported])
AC_SUBST([sharedlib_cflags])
AC_CONFIG_FILES([Makefile.common])
AC_CONFIG_FILES([Makefile.config])
+AC_CONFIG_FILES([tools/eventlog_metadata])
AC_CONFIG_HEADERS([runtime/caml/m.h])
AC_CONFIG_HEADERS([runtime/caml/s.h])
[],
[ocamldoc=auto])
+AC_ARG_ENABLE([ocamltest],
+ [AS_HELP_STRING([--disable-ocamltest],
+ [do not build the ocamltest driver])])
+
AC_ARG_ENABLE([frame-pointers],
[AS_HELP_STRING([--enable-frame-pointers],
[use frame pointers in runtime and generated code])])
[outputobj='-o $(EMPTY)'; gcc_warnings="-qflag=i:i"], # all warnings enabled
[msvc-*],
[outputobj=-Fo; gcc_warnings=""],
- [outputobj='-o $(EMPTY)'; AS_CASE([AC_PACKAGE_VERSION],
+ [outputobj='-o $(EMPTY)'
+ gcc_warnings='-Wall -Wdeclaration-after-statement'
+ AS_CASE([AC_PACKAGE_VERSION],
[*+dev*],
- [gcc_warnings="-Wall -Werror"],
- [gcc_warnings="-Wall"]
- )]
-)
+ [gcc_warnings="$gcc_warnings -Werror"])
+ ])
# We select high optimization levels, provided we can turn off:
# - strict type-based aliasing analysis (too risky for the OCaml runtime)
# in the macro itself, too
AS_CASE([$host],
[*-*-mingw32],
- [internal_cflags="-Wno-unused $gcc_warnings"
- # TODO: see whether the code can be fixed to avoid -Wno-unused
- common_cflags="-O -mms-bitfields"
- internal_cppflags='-DUNICODE -D_UNICODE'
- internal_cppflags="$internal_cppflags -DWINDOWS_UNICODE="
- internal_cppflags="${internal_cppflags}\$(WINDOWS_UNICODE)"],
+ [AS_CASE([$ocaml_cv_cc_vendor],
+ [gcc-[[01234]]-*],
+ [AC_MSG_ERROR(m4_normalize([This version of Mingw GCC is too old.
+ Please use GCC version 5 or above.]))],
+ [gcc-*],
+ [internal_cflags="-Wno-unused $gcc_warnings \
+-fexcess-precision=standard"
+ # TODO: see whether the code can be fixed to avoid -Wno-unused
+ common_cflags="-O2 -fno-strict-aliasing -fwrapv -mms-bitfields"
+ internal_cppflags='-DUNICODE -D_UNICODE'
+ internal_cppflags="$internal_cppflags -DWINDOWS_UNICODE="
+ internal_cppflags="${internal_cppflags}\$(WINDOWS_UNICODE)"],
+ [AC_MSG_ERROR([Unsupported C compiler for a Mingw build])])],
[AS_CASE([$ocaml_cv_cc_vendor],
[clang-*],
[common_cflags="-O2 -fno-strict-aliasing -fwrapv";
internal_cflags="$gcc_warnings -fno-common"],
- [gcc-[012]-*],
+ [gcc-[[012]]-*],
# Some versions known to miscompile OCaml, e,g, 2.7.2.1, some 2.96.
# Plus: C99 support unknown.
- [AC_MSG_ERROR([This version of GCC is too old.
- Please use GCC version 4.2 or above.])],
- [gcc-3-*|gcc-4-[01]],
+ [AC_MSG_ERROR(m4_normalize([This version of GCC is too old.
+ Please use GCC version 4.2 or above.]))],
+ [gcc-3-*|gcc-4-[[01]]],
# No -fwrapv option before GCC 3.4.
# Known problems with -fwrapv fixed in 4.2 only.
- [AC_MSG_WARN([This version of GCC is rather old.
- Reducing optimization level."]);
+ [AC_MSG_WARN(m4_normalize([This version of GCC is rather old.
+ Reducing optimization level."]));
AC_MSG_WARN([Consider using GCC version 4.2 or above.]);
common_cflags="-std=gnu99 -O";
internal_cflags="$gcc_warnings"],
- [gcc-4-*],
+ [gcc-4-[[234]]],
+ # No -fexcess-precision option before GCC 4.5
[common_cflags="-std=gnu99 -O2 -fno-strict-aliasing -fwrapv \
-fno-builtin-memcmp";
internal_cflags="$gcc_warnings"],
+ [gcc-4-*],
+ [common_cflags="-std=gnu99 -O2 -fno-strict-aliasing -fwrapv \
+-fno-builtin-memcmp";
+ internal_cflags="$gcc_warnings -fexcess-precision=standard"],
[gcc-*],
[common_cflags="-O2 -fno-strict-aliasing -fwrapv";
- internal_cflags="$gcc_warnings -fno-common"],
+ internal_cflags="$gcc_warnings -fno-common \
+-fexcess-precision=standard"],
[msvc-*],
[common_cflags="-nologo -O2 -Gy- -MD"
common_cppflags="-D_CRT_SECURE_NO_DEPRECATE"
AC_MSG_NOTICE([Target is a $bits bits architecture])
AC_C_BIGENDIAN(
- [AC_DEFINE([ARCH_BIG_ENDIAN], [1])],
- [],
+ [
+ AC_DEFINE([ARCH_BIG_ENDIAN], [1]),
+ [endianness="be"]
+ ],
+ [endianness="le"],
[AC_MSG_ERROR([could not determine endianness.])],
[AC_MSG_ERROR([unable to handle universal endianness])]
)
AC_CHECK_ALIGNOF([double])
AC_CHECK_ALIGNOF([long])
+AC_CHECK_ALIGNOF([long long])
AS_IF([! $arch64],
[AS_CASE([$target_cpu],
[i686], [],
[AS_IF([test "$ac_cv_alignof_double" -gt 4],
[AC_DEFINE([ARCH_ALIGN_DOUBLE], [1])])
- AS_IF([test "$ac_cv_alignof_long" -gt 4],
- [AC_DEFINE([ARCH_ALIGN_LONG], [1])])
+ AS_IF([test "x$ac_cv_sizeof_long" = "x8" &&
+ test "$ac_cv_alignof_long" -gt 4],
+ [AC_DEFINE([ARCH_ALIGN_INT64], [1])],
+ [AS_IF([test "x$ac_cv_sizeof_long_long" = "x8" &&
+ test "$ac_cv_alignof_long_long" -gt 4],
+ [AC_DEFINE([ARCH_ALIGN_INT64], [1])])])
])])
# Shared library support
[arm*-*-freebsd*], [natdynlink=true],
[earm*-*-netbsd*], [natdynlink=true],
[aarch64-*-linux*], [natdynlink=true],
- [aarch64-*-freebsd*], [natdynlink=true])])
+ [aarch64-*-freebsd*], [natdynlink=true],
+ [riscv*-*-linux*], [natdynlink=true])])
# Try to work around the Skylake/Kaby Lake processor bug.
AS_CASE(["$CC,$host"],
[aarch64-*-freebsd*],
[arch=arm64; system=freebsd],
[x86_64-*-cygwin*],
- [arch=amd64; system=cygwin]
+ [arch=amd64; system=cygwin],
+ [riscv64-*-linux*],
+ [arch=riscv; model=riscv64; system=linux]
)
AS_IF([test x"$enable_native_compiler" = "xno"],
AS_IF([test $arch != "none" && $arch64 ],
[otherlibraries="$otherlibraries raw_spacetime_lib"])
+# Disable PIE at link time when ocamlopt does not produce position-independent
+# code and the system produces PIE executables by default and demands PIC
+# object files to do so.
+# This issue does not affect amd64 (x86_64) and s390x (Z systems),
+# since ocamlopt produces PIC object files by default.
+# Currently the problem is known for Alpine Linux on platforms other
+# than amd64 and s390x (issue #7562), and probably affects all Linux
+# distributions that use the musl standard library and dynamic loader.
+# Other systems have PIE by default but can cope with non-PIC object files,
+# e.g. Ubuntu >= 17.10 for i386, which uses the glibc dynamic loader.
+
+AS_CASE([$arch],
+ [amd64|s390x|none],
+ # ocamlopt generates PIC code or doesn't generate code at all
+ [],
+ [AS_CASE([$host],
+ [*-linux-musl],
+ # Alpine and other musl-based Linux distributions
+ [common_cflags="-no-pie $common_cflags"],
+ [])])
+
# Assembler
AS_IF([test -n "$host_alias"], [toolpref="${host_alias}-"], [toolpref=""])
[*,dragonfly],
[default_as="${toolpref}as"
default_aspp="${toolpref}cc -c"],
- [amd64,*|arm,*|arm64,*|i386,*],
+ [amd64,*|arm,*|arm64,*|i386,*|riscv,*],
[AS_CASE([$ocaml_cv_cc_vendor],
[clang-*], [default_as="${toolpref}clang -c -Wno-trigraphs"
default_aspp="${toolpref}clang -c -Wno-trigraphs"],
AC_CHECK_FUNC([issetugid], [AC_DEFINE([HAS_ISSETUGID])])
-## clock_gettime, for the instrumented runtime
+## Checking for monotonic clock source
+## On Windows MSVC, QueryPerformanceCounter and QueryPerformanceFrequency
+## are always available.
+## On Unix platforms, we check for the appropriate POSIX feature-test macros.
+## On MacOS clock_gettime's CLOCK_MONOTONIC flag is not actually monotonic.
+## mach_timebase_info and mach_absolute_time are used instead.
-## Note: on MinGW, configure finds a clock_gettime and thus the build
-# system tries to build the instrumented runtime, which causes
-# warnings. For the moment we simply disable it on MinGW
-# but this would need to be further investigated
AS_CASE([$host],
- [*-*-mingw32], [instrumented_runtime=false],
- [AS_IF([test "x$enable_instrumented_runtime" = "xno" ],
- [instrumented_runtime=false; instrumented_runtime_libs=""],
+ [*-*-windows],
+ [has_monotonic_clock=true],
+ [*-apple-darwin*], [
+ AC_CHECK_FUNCS([mach_timebase_info mach_absolute_time],
+ [
+ has_monotonic_clock=true
+ AC_DEFINE([HAS_MACH_ABSOLUTE_TIME])
+ ],
+ [has_monotonic_clock=false])],
+ [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
+ #include <unistd.h>
+ #include <time.h>
+ int main(void)
+ {
+ #if !(defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK) \
+ && _POSIX_MONOTONIC_CLOCK != (-1))
+ #error "no monotonic clock source"
+ #endif
+ return 0;
+ }
+ ]])],
[
- AC_SEARCH_LIBS([clock_gettime], [rt],
- [has_clock_gettime=true],
- [has_clock_gettime=false])
- AS_CASE([$enable_instrumented_runtime,$has_clock_gettime],
+ has_monotonic_clock=true
+ AC_DEFINE([HAS_POSIX_MONOTONIC_CLOCK])
+ ],
+ [has_monotonic_clock=false])
+ ]
+)
+
+# The instrumented runtime is built by default
+# if the proper clock source is found.
+# If asked via --enable-instrumented-runtime, configuration fails if the proper
+# clock source is missing.
+AS_IF([test "x$enable_instrumented_runtime" != "xno" ],
+ [
+ AS_CASE([$host],
+ [*-*-windows],
+ [instrumented_runtime=true],
+ [*-apple-darwin*], [
+ AS_CASE([$enable_instrumented_runtime,$has_monotonic_clock],
[*,true],
- [instrumented_runtime=true
- AS_IF([test "x$ac_cv_search_clock_gettime" = "xnone required"],
- [instrumented_runtime_libs=""],
- [instrumented_runtime_libs=$ac_cv_search_clock_gettime])],
- [auto,*],
- [instrumented_runtime=false],
- [yes,*],
- [AC_MSG_ERROR([the instrumented runtime can not be built])])])])
+ [instrumented_runtime=true],
+ [yes,false], [
+ AC_MSG_ERROR([Instrumented runtime support requested \
+but no proper monotonic clock source was found.])
+ ],
+ [auto,false],
+ [instrumented_runtime=false]
+ )],
+ [AC_SEARCH_LIBS([clock_gettime], [rt],
+ [has_clock_gettime=true],
+ [has_clock_gettime=false])
+ AS_CASE(
+ [$enable_instrumented_runtime,$has_clock_gettime,$has_monotonic_clock],
+ [auto,false,*], [instrumented_runtime=false],
+ [auto,*,false], [instrumented_runtime=false],
+ [*,true,true],
+ [
+ instrumented_runtime=true
+ AS_IF([test "x$ac_cv_search_clock_gettime" = "xnone required"],
+ [instrumented_runtime_ldlibs=""],
+ [instrumented_runtime_ldlibs=$ac_cv_search_clock_gettime]
+ )
+ ],
+ [yes,false,*],
+ [
+ AC_MSG_ERROR([Instrumented runtime support requested \
+but clock_gettime is missing.])
+ ],
+ [yes,*,false],
+ [
+ AC_MSG_ERROR([Instrumented runtime support requested \
+but no proper monotonic clock source was found.])
+ ]
+ )]
+ )]
+)
## Sockets
[*-*-mingw32|*-pc-windows],
[cclibs="$cclibs -lws2_32"
sockets=true],
+ [*-*-haiku],
+ [cclibs="$cclibs -lnetwork"
+ sockets=true],
[
AC_CHECK_FUNC([socket])
AC_CHECK_FUNC([socketpair])
AC_CHECK_FUNC([putenv], [AC_DEFINE([HAS_PUTENV])])
+## setenv and unsetenv
+
+AC_CHECK_FUNC([setenv],
+ [AC_CHECK_FUNC([unsetenv], [AC_DEFINE([HAS_SETENV_UNSETENV])])])
+
## newlocale() and <locale.h>
# Note: the detection fails on msvc so we hardcode the result
# (should be debugged later)
[ocamldoc=""],
[ocamldoc=ocamldoc])
+AS_CASE([$enable_ocamltest,AC_PACKAGE_VERSION],
+ [yes,*|,*+dev*],[ocamltest='ocamltest'],
+ [ocamltest=''])
+
AS_IF([test x"$enable_flambda" = "xyes"],
[flambda=true
AS_IF([test x"$enable_flambda_invariants" = "xyes"],
oc_cppflags="$common_cppflags $internal_cppflags"
ocamlc_cflags="$common_cflags $sharedlib_cflags"
ocamlc_cppflags="$common_cppflags"
-ocamlopt_cflags="$common_cflags"
-ocamlopt_cppflags="$common_cppflags"
cclibs="$cclibs $mathlib"
AS_CASE([$host],
[*-pc-windows],
[bytecclibs="advapi32.lib ws2_32.lib version.lib"
nativecclibs="advapi32.lib ws2_32.lib version.lib"],
- [bytecclibs="$cclibs $DLLIBS $pthread_link $instrumented_runtime_libs"
+ [bytecclibs="$cclibs $DLLIBS $pthread_link $instrumented_runtime_ldlibs"
nativecclibs="$cclibs $DLLIBS"])
AS_IF([test x"$libdir" = x'${exec_prefix}/lib'],
primitives.cmi \
pos.cmi \
parser_aux.cmi \
- parser.cmi \
parameters.cmi \
../parsing/longident.cmi \
../parsing/location.cmi \
loadprinter.cmi \
../utils/load_path.cmi \
- lexer.cmi \
int64ops.cmi \
../bytecomp/instruct.cmi \
input_handling.cmi \
eval.cmi \
../typing/envaux.cmi \
../typing/env.cmi \
+ debugger_parser.cmi \
+ debugger_lexer.cmi \
debugger_config.cmi \
debugcom.cmi \
../typing/ctype.cmi \
primitives.cmx \
pos.cmx \
parser_aux.cmi \
- parser.cmx \
parameters.cmx \
../parsing/longident.cmx \
../parsing/location.cmx \
loadprinter.cmx \
../utils/load_path.cmx \
- lexer.cmx \
int64ops.cmx \
../bytecomp/instruct.cmx \
input_handling.cmx \
eval.cmx \
../typing/envaux.cmx \
../typing/env.cmx \
+ debugger_parser.cmx \
+ debugger_lexer.cmx \
debugger_config.cmx \
debugcom.cmx \
../typing/ctype.cmx \
int64ops.cmx \
debugger_config.cmi
debugger_config.cmi :
+debugger_lexer.cmo : \
+ debugger_parser.cmi \
+ debugger_lexer.cmi
+debugger_lexer.cmx : \
+ debugger_parser.cmx \
+ debugger_lexer.cmi
+debugger_lexer.cmi : \
+ debugger_parser.cmi
+debugger_parser.cmo : \
+ parser_aux.cmi \
+ ../parsing/longident.cmi \
+ int64ops.cmi \
+ input_handling.cmi \
+ debugcom.cmi \
+ debugger_parser.cmi
+debugger_parser.cmx : \
+ parser_aux.cmi \
+ ../parsing/longident.cmx \
+ int64ops.cmx \
+ input_handling.cmx \
+ debugcom.cmx \
+ debugger_parser.cmi
+debugger_parser.cmi : \
+ parser_aux.cmi \
+ ../parsing/longident.cmi
eval.cmo : \
../typing/types.cmi \
../bytecomp/symtable.cmi \
int64ops.cmx : \
int64ops.cmi
int64ops.cmi :
-lexer.cmo : \
- parser.cmi \
- lexer.cmi
-lexer.cmx : \
- parser.cmx \
- lexer.cmi
-lexer.cmi : \
- parser.cmi
loadprinter.cmo : \
../typing/types.cmi \
../bytecomp/symtable.cmi \
../utils/config.cmx \
parameters.cmi
parameters.cmi :
-parser.cmo : \
- parser_aux.cmi \
- ../parsing/longident.cmi \
- int64ops.cmi \
- input_handling.cmi \
- debugcom.cmi \
- parser.cmi
-parser.cmx : \
- parser_aux.cmi \
- ../parsing/longident.cmx \
- int64ops.cmx \
- input_handling.cmx \
- debugcom.cmx \
- parser.cmi
-parser.cmi : \
- parser_aux.cmi \
- ../parsing/longident.cmi
parser_aux.cmi : \
../parsing/longident.cmi \
debugcom.cmi
program_management.cmi :
question.cmo : \
primitives.cmi \
- lexer.cmi \
input_handling.cmi \
+ debugger_lexer.cmi \
question.cmi
question.cmx : \
primitives.cmx \
- lexer.cmx \
input_handling.cmx \
+ debugger_lexer.cmx \
question.cmi
question.cmi :
show_information.cmo : \
ROOTDIR = ..
-include $(ROOTDIR)/Makefile.config
-include $(ROOTDIR)/Makefile.common
+-include $(ROOTDIR)/Makefile.config
+-include $(ROOTDIR)/Makefile.common
include $(ROOTDIR)/Makefile.best_binaries
DYNLINKDIR=$(ROOTDIR)/otherlibs/dynlink
INCLUDES=$(addprefix -I ,$(DIRECTORIES))
-utils_modules := $(addprefix utils/,\
- config build_path_prefix_map misc identifiable numbers arg_helper clflags \
- consistbl warnings terminfo load_path)
-
-parsing_modules := $(addprefix parsing/,\
- location longident docstrings syntaxerr ast_helper ast_mapper ast_iterator \
- attr_helper builtin_attributes pprintast)
-
-typing_modules := $(addprefix typing/,\
- ident path type_immediacy types btype primitive typedtree subst predef \
- datarepr persistent_env env oprint ctype printtyp mtype envaux)
-
-file_formats_modules := $(addprefix file_formats/,\
- cmi_format)
-
-lambda_modules := $(addprefix lambda/,\
- runtimedef)
-
-bytecomp_modules := $(addprefix bytecomp/,\
- bytesections dll meta symtable opcodes)
-
-other_compiler_modules := toplevel/genprintval
-
-compiler_modules := $(addprefix $(ROOTDIR)/,\
- $(utils_modules) $(parsing_modules) $(file_formats_modules) \
- $(lambda_modules) \
- $(typing_modules) $(bytecomp_modules) $(other_compiler_modules))
+compiler_modules := $(ROOTDIR)/toplevel/genprintval
debugger_modules := \
- int64ops primitives unix_tools debugger_config parameters lexer \
+ int64ops primitives unix_tools debugger_config parameters debugger_lexer \
input_handling question debugcom exec source pos checkpoints events \
program_loading symbols breakpoints trap_barrier history printval \
show_source time_travel program_management frames eval \
- show_information loadprinter parser command_line main
+ show_information loadprinter debugger_parser command_line main
all_modules := $(compiler_modules) $(debugger_modules)
all_objects := $(addsuffix .cmo,$(all_modules))
+libraries = $(ROOTDIR)/compilerlibs/ocamlcommon.cma \
+ $(UNIXDIR)/unix.cma $(DYNLINKDIR)/dynlink.cma
+
all: ocamldebug$(EXE)
-ocamldebug$(EXE): $(UNIXDIR)/unix.cma $(DYNLINKDIR)/dynlink.cma $(all_objects)
+ocamldebug$(EXE): $(libraries) $(all_objects)
$(CAMLC) $(LINKFLAGS) -o $@ -linkall $^
install:
$(INSTALL_PROG) ocamldebug$(EXE) "$(INSTALL_BINDIR)/ocamldebug$(EXE)"
clean::
- rm -f ocamldebug$(EXE)
+ rm -f ocamldebug ocamldebug.exe
rm -f *.cmo *.cmi
.SUFFIXES:
$(CAMLDEP) $(DEPFLAGS) $(DEPINCLUDES) *.mli *.ml \
| sed -e 's,$(UNIXDIR)/,$$(UNIXDIR)/,' > .depend
-lexer.ml: lexer.mll
+debugger_lexer.ml: debugger_lexer.mll
$(CAMLLEX) $(OCAMLLEX_FLAGS) $<
clean::
- rm -f lexer.ml
-beforedepend:: lexer.ml
+ rm -f debugger_lexer.ml
+beforedepend:: debugger_lexer.ml
-parser.ml parser.mli: parser.mly
- $(CAMLYACC) parser.mly
+debugger_parser.ml debugger_parser.mli: debugger_parser.mly
+ $(CAMLYACC) debugger_parser.mly
clean::
- rm -f parser.ml parser.mli
-beforedepend:: parser.ml parser.mli
+ rm -f debugger_parser.ml debugger_parser.mli
+beforedepend:: debugger_parser.ml debugger_parser.mli
include .depend
in
Exec.protect (function () -> insert_position pc);
temporary_breakpoint_position := Some pc;
- try
- funct ();
- Exec.protect remove
- with
- x ->
- Exec.protect remove;
- raise x
+ Fun.protect ~finally:(fun () -> Exec.protect remove) funct
open Types
open Primitives
open Unix_tools
-open Parser
+open Debugger_parser
open Parser_aux
-open Lexer
+open Debugger_lexer
open Input_handling
open Question
open Debugcom
open Frames
open Printval
+module Lexer = Debugger_lexer
+
(** Instructions, variables and infos lists. **)
type dbg_instruction =
{ instr_name: string; (* Name of command *)
done
with
| Exit ->
- stop_user_input ()
+ ()
(* | Sys_error s ->
error ("System error: " ^ s) *)
| Not_found -> error "Source file not found."
| (Unix_error _) as x -> Unix_tools.report_error x; raise Toplevel
in
- try
- interactif := false;
- user_channel := io_chan;
- line_loop ppf (Lexing.from_function read_user_input);
+ interactif := false;
+ user_channel := io_chan;
+ let loop () =
+ line_loop ppf (Lexing.from_function read_user_input)
+ and finally () =
+ stop_user_input ();
close_io io_chan;
interactif := old_state;
user_channel := old_channel
- with
- | x ->
- stop_user_input ();
- close_io io_chan;
- interactif := old_state;
- user_channel := old_channel;
- raise x
+ in
+ Fun.protect ~finally loop
let instr_set =
find_variable
--- /dev/null
+(**************************************************************************)
+(* *)
+(* OCaml *)
+(* *)
+(* Jerome Vouillon, projet Cristal, INRIA Rocquencourt *)
+(* OCaml port by John Malecki and Xavier Leroy *)
+(* *)
+(* Copyright 1996 Institut National de Recherche en Informatique et *)
+(* en Automatique. *)
+(* *)
+(* All rights reserved. This file is distributed under the terms of *)
+(* the GNU Lesser General Public License version 2.1, with the *)
+(* special exception on linking described in the file LICENSE. *)
+(* *)
+(**************************************************************************)
+
+exception Int_overflow
+
+val line: Lexing.lexbuf -> string
+val lexeme: Lexing.lexbuf -> Debugger_parser.token
+val argument: Lexing.lexbuf -> Debugger_parser.token
+val line_argument: Lexing.lexbuf -> Debugger_parser.token
--- /dev/null
+(**************************************************************************)
+(* *)
+(* OCaml *)
+(* *)
+(* Jerome Vouillon, projet Cristal, INRIA Rocquencourt *)
+(* OCaml port by John Malecki and Xavier Leroy *)
+(* *)
+(* Copyright 1996 Institut National de Recherche en Informatique et *)
+(* en Automatique. *)
+(* *)
+(* All rights reserved. This file is distributed under the terms of *)
+(* the GNU Lesser General Public License version 2.1, with the *)
+(* special exception on linking described in the file LICENSE. *)
+(* *)
+(**************************************************************************)
+
+{
+
+open Debugger_parser
+
+exception Int_overflow
+
+}
+
+rule line = (* Read a whole line *)
+ parse
+ ([ ^ '\n' '\r' ]* as s) ('\n' | '\r' | "\r\n")
+ { s }
+ | [ ^ '\n' '\r' ]*
+ { Lexing.lexeme lexbuf }
+ | eof
+ { raise Exit }
+
+and argument = (* Read a raw argument *)
+ parse
+ [ ^ ' ' '\t' ]+
+ { ARGUMENT (Lexing.lexeme lexbuf) }
+ | [' ' '\t']+
+ { argument lexbuf }
+ | eof
+ { EOL }
+ | _
+ { raise Parsing.Parse_error }
+
+and line_argument =
+ parse
+ _ *
+ { ARGUMENT (Lexing.lexeme lexbuf) }
+ | eof
+ { EOL }
+
+and lexeme = (* Read a lexeme *)
+ parse
+ [' ' '\t'] +
+ { lexeme lexbuf }
+ | ['a'-'z' '\223'-'\246' '\248'-'\255' '_']
+ (['A'-'Z' 'a'-'z' '_' '\192'-'\214' '\216'-'\246' '\248'-'\255'
+ '\'' '0'-'9' ]) *
+ { LIDENT(Lexing.lexeme lexbuf) }
+ | ['A'-'Z' '\192'-'\214' '\216'-'\222' ]
+ (['A'-'Z' 'a'-'z' '_' '\192'-'\214' '\216'-'\246' '\248'-'\255'
+ '\'' '0'-'9' ]) *
+ { UIDENT(Lexing.lexeme lexbuf) }
+ | '"' [^ '"']* "\""
+ { let s = Lexing.lexeme lexbuf in
+ LIDENT(String.sub s 1 (String.length s - 2)) }
+ | ['0'-'9']+
+ | '0' ['x' 'X'] ['0'-'9' 'A'-'F' 'a'-'f']+
+ | '0' ['o' 'O'] ['0'-'7']+
+ | '0' ['b' 'B'] ['0'-'1']+
+ { try INTEGER (Int64.of_string (Lexing.lexeme lexbuf))
+ with Failure _ -> raise Int_overflow
+ }
+ | '*'
+ { STAR }
+ | "-"
+ { MINUS }
+ | "."
+ { DOT }
+ | "#"
+ { HASH }
+ | "@"
+ { AT }
+ | "$"
+ { DOLLAR }
+ | ":"
+ { COLON }
+ | "!"
+ { BANG }
+ | "("
+ { LPAREN }
+ | ")"
+ { RPAREN }
+ | "["
+ { LBRACKET }
+ | "]"
+ { RBRACKET }
+ | ['!' '?' '~' '=' '<' '>' '|' '&' '$' '@' '^' '+' '-' '*' '/' '%']
+ ['!' '$' '%' '&' '*' '+' '-' '.' '/' ':' '<' '=' '>' '?' '@' '^' '|' '~'] *
+ { OPERATOR (Lexing.lexeme lexbuf) }
+ | eof
+ { EOL }
+ | _
+ { raise Parsing.Parse_error }
--- /dev/null
+/**************************************************************************/
+/* */
+/* OCaml */
+/* */
+/* Jerome Vouillon, projet Cristal, INRIA Rocquencourt */
+/* OCaml port by John Malecki and Xavier Leroy */
+/* */
+/* Copyright 1996 Institut National de Recherche en Informatique et */
+/* en Automatique. */
+/* */
+/* All rights reserved. This file is distributed under the terms of */
+/* the GNU Lesser General Public License version 2.1, with the */
+/* special exception on linking described in the file LICENSE. */
+/* */
+/**************************************************************************/
+
+%{
+
+open Int64ops
+open Input_handling
+open Longident
+open Parser_aux
+open Debugcom
+
+%}
+
+%token <string> ARGUMENT
+%token <string> LIDENT
+%token <string> UIDENT
+%token <string> OPERATOR
+%token <int64> INTEGER
+%token STAR /* * */
+%token MINUS /* - */
+%token DOT /* . */
+%token COLON /* : */
+%token HASH /* # */
+%token AT /* @ */
+%token DOLLAR /* $ */
+%token BANG /* ! */
+%token LPAREN /* ( */
+%token RPAREN /* ) */
+%token LBRACKET /* [ */
+%token RBRACKET /* ] */
+%token EOL
+
+%right DOT
+%right BANG
+
+%start argument_list_eol
+%type <string list> argument_list_eol
+
+%start argument_eol
+%type <string> argument_eol
+
+%start integer_list_eol
+%type <int list> integer_list_eol
+
+%start integer_eol
+%type <int> integer_eol
+
+%start int64_eol
+%type <int64> int64_eol
+
+%start integer
+%type <int> integer
+
+%start opt_integer_eol
+%type <int option> opt_integer_eol
+
+%start opt_signed_integer_eol
+%type <int option> opt_signed_integer_eol
+
+%start opt_signed_int64_eol
+%type <int64 option> opt_signed_int64_eol
+
+%start identifier
+%type <string> identifier
+
+%start identifier_eol
+%type <string> identifier_eol
+
+%start identifier_or_eol
+%type <string option> identifier_or_eol
+
+%start opt_identifier
+%type <string option> opt_identifier
+
+%start opt_identifier_eol
+%type <string option> opt_identifier_eol
+
+%start expression_list_eol
+%type <Parser_aux.expression list> expression_list_eol
+
+%start break_argument_eol
+%type <Parser_aux.break_arg> break_argument_eol
+
+%start list_arguments_eol
+%type <Longident.t option * int option * int option> list_arguments_eol
+
+%start end_of_line
+%type <unit> end_of_line
+
+%start longident_eol
+%type <Longident.t> longident_eol
+
+%start opt_longident
+%type <Longident.t option> opt_longident
+
+%start opt_longident_eol
+%type <Longident.t option> opt_longident_eol
+
+%%
+
+/* Raw arguments */
+
+argument_list_eol :
+ ARGUMENT argument_list_eol
+ { $1::$2 }
+ | end_of_line
+ { [] };
+
+argument_eol :
+ ARGUMENT end_of_line
+ { $1 };
+
+/* Integer */
+
+integer_list_eol :
+ INTEGER integer_list_eol
+ { (to_int $1) :: $2 }
+ | end_of_line
+ { [] };
+
+integer_eol :
+ INTEGER end_of_line
+ { to_int $1 };
+
+int64_eol :
+ INTEGER end_of_line
+ { $1 };
+
+integer :
+ INTEGER
+ { to_int $1 };
+
+opt_integer_eol :
+ INTEGER end_of_line
+ { Some (to_int $1) }
+ | end_of_line
+ { None };
+
+opt_int64_eol :
+ INTEGER end_of_line
+ { Some $1 }
+ | end_of_line
+ { None };
+
+opt_signed_integer_eol :
+ MINUS integer_eol
+ { Some (- $2) }
+ | opt_integer_eol
+ { $1 };
+
+opt_signed_int64_eol :
+ MINUS int64_eol
+ { Some (Int64.neg $2) }
+ | opt_int64_eol
+ { $1 };
+
+/* Identifiers and long identifiers */
+
+longident :
+ LIDENT { Lident $1 }
+ | module_path DOT LIDENT { Ldot($1, $3) }
+ | OPERATOR { Lident $1 }
+ | module_path DOT OPERATOR { Ldot($1, $3) }
+ | module_path DOT LPAREN OPERATOR RPAREN { Ldot($1, $4) }
+;
+
+module_path :
+ UIDENT { Lident $1 }
+ | module_path DOT UIDENT { Ldot($1, $3) }
+;
+
+longident_eol :
+ longident end_of_line { $1 };
+
+opt_longident :
+ UIDENT { Some (Lident $1) }
+ | LIDENT { Some (Lident $1) }
+ | module_path DOT UIDENT { Some (Ldot($1, $3)) }
+ | { None };
+
+opt_longident_eol :
+ opt_longident end_of_line { $1 };
+
+identifier :
+ LIDENT { $1 }
+ | UIDENT { $1 };
+
+identifier_eol :
+ identifier end_of_line { $1 };
+
+identifier_or_eol :
+ identifier { Some $1 }
+ | end_of_line { None };
+
+opt_identifier :
+ identifier { Some $1 }
+ | { None };
+
+opt_identifier_eol :
+ opt_identifier end_of_line { $1 };
+
+/* Expressions */
+
+expression:
+ longident { E_ident $1 }
+ | STAR { E_result }
+ | DOLLAR INTEGER { E_name (to_int $2) }
+ | expression DOT INTEGER { E_item($1, (to_int $3)) }
+ | expression DOT LBRACKET INTEGER RBRACKET { E_item($1, (to_int $4)) }
+ | expression DOT LPAREN INTEGER RPAREN { E_item($1, (to_int $4)) }
+ | expression DOT LIDENT { E_field($1, $3) }
+ | BANG expression { E_field($2, "contents") }
+ | LPAREN expression RPAREN { $2 }
+;
+
+/* Lists of expressions */
+
+expression_list_eol :
+ expression expression_list_eol { $1::$2 }
+ | end_of_line { [] }
+;
+
+/* Arguments for breakpoint */
+
+break_argument_eol :
+ end_of_line { BA_none }
+ | integer_eol { BA_pc {frag = 0; pos = $1} }
+ | INTEGER COLON integer_eol { BA_pc {frag = to_int $1;
+ pos = $3} }
+ | expression end_of_line { BA_function $1 }
+ | AT opt_longident INTEGER opt_integer_eol { BA_pos1 ($2, (to_int $3), $4)}
+ | AT opt_longident HASH integer_eol { BA_pos2 ($2, $4) }
+;
+
+/* Arguments for list */
+
+list_arguments_eol :
+ opt_longident integer opt_integer_eol
+ { ($1, Some $2, $3) }
+ | opt_longident_eol
+ { ($1, None, None) };
+
+/* End of line */
+
+end_of_line :
+ EOL { stop_user_input () }
+;
let execute_with_other_controller controller file funct =
let old_controller = current_controller file in
change_controller file controller;
- try
- let result = funct () in
- change_controller file old_controller;
- result
- with
- x ->
- change_controller file old_controller;
- raise x
+ let finally () = change_controller file old_controller in
+ Fun.protect ~finally funct
(*** The "Main Loop" ***)
(* Handle active files until `continue_main_loop' is false. *)
let main_loop () =
- let old_state = !continue_main_loop in
- try
+ let finally =
+ let old_state = !continue_main_loop in
+ fun () -> continue_main_loop := old_state
+ in
+ Fun.protect ~finally @@ fun () ->
continue_main_loop := true;
while !continue_main_loop do
try
input
with
Unix_error (EINTR, _, _) -> ()
- done;
- continue_main_loop := old_state
- with
- x ->
- continue_main_loop := old_state;
- raise x
+ done
(*** Managing user inputs ***)
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* OCaml *)
-(* *)
-(* Jerome Vouillon, projet Cristal, INRIA Rocquencourt *)
-(* OCaml port by John Malecki and Xavier Leroy *)
-(* *)
-(* Copyright 1996 Institut National de Recherche en Informatique et *)
-(* en Automatique. *)
-(* *)
-(* All rights reserved. This file is distributed under the terms of *)
-(* the GNU Lesser General Public License version 2.1, with the *)
-(* special exception on linking described in the file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-exception Int_overflow
-
-val line: Lexing.lexbuf -> string
-val lexeme: Lexing.lexbuf -> Parser.token
-val argument: Lexing.lexbuf -> Parser.token
-val line_argument: Lexing.lexbuf -> Parser.token
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* OCaml *)
-(* *)
-(* Jerome Vouillon, projet Cristal, INRIA Rocquencourt *)
-(* OCaml port by John Malecki and Xavier Leroy *)
-(* *)
-(* Copyright 1996 Institut National de Recherche en Informatique et *)
-(* en Automatique. *)
-(* *)
-(* All rights reserved. This file is distributed under the terms of *)
-(* the GNU Lesser General Public License version 2.1, with the *)
-(* special exception on linking described in the file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-{
-
-open Parser
-
-exception Int_overflow
-
-}
-
-rule line = (* Read a whole line *)
- parse
- ([ ^ '\n' '\r' ]* as s) ('\n' | '\r' | "\r\n")
- { s }
- | [ ^ '\n' '\r' ]*
- { Lexing.lexeme lexbuf }
- | eof
- { raise Exit }
-
-and argument = (* Read a raw argument *)
- parse
- [ ^ ' ' '\t' ]+
- { ARGUMENT (Lexing.lexeme lexbuf) }
- | [' ' '\t']+
- { argument lexbuf }
- | eof
- { EOL }
- | _
- { raise Parsing.Parse_error }
-
-and line_argument =
- parse
- _ *
- { ARGUMENT (Lexing.lexeme lexbuf) }
- | eof
- { EOL }
-
-and lexeme = (* Read a lexeme *)
- parse
- [' ' '\t'] +
- { lexeme lexbuf }
- | ['a'-'z' '\223'-'\246' '\248'-'\255' '_']
- (['A'-'Z' 'a'-'z' '_' '\192'-'\214' '\216'-'\246' '\248'-'\255'
- '\'' '0'-'9' ]) *
- { LIDENT(Lexing.lexeme lexbuf) }
- | ['A'-'Z' '\192'-'\214' '\216'-'\222' ]
- (['A'-'Z' 'a'-'z' '_' '\192'-'\214' '\216'-'\246' '\248'-'\255'
- '\'' '0'-'9' ]) *
- { UIDENT(Lexing.lexeme lexbuf) }
- | '"' [^ '"']* "\""
- { let s = Lexing.lexeme lexbuf in
- LIDENT(String.sub s 1 (String.length s - 2)) }
- | ['0'-'9']+
- | '0' ['x' 'X'] ['0'-'9' 'A'-'F' 'a'-'f']+
- | '0' ['o' 'O'] ['0'-'7']+
- | '0' ['b' 'B'] ['0'-'1']+
- { try INTEGER (Int64.of_string (Lexing.lexeme lexbuf))
- with Failure _ -> raise Int_overflow
- }
- | '*'
- { STAR }
- | "-"
- { MINUS }
- | "."
- { DOT }
- | "#"
- { HASH }
- | "@"
- { AT }
- | "$"
- { DOLLAR }
- | ":"
- { COLON }
- | "!"
- { BANG }
- | "("
- { LPAREN }
- | ")"
- { RPAREN }
- | "["
- { LBRACKET }
- | "]"
- { RBRACKET }
- | ['!' '?' '~' '=' '<' '>' '|' '&' '$' '@' '^' '+' '-' '*' '/' '%']
- ['!' '$' '%' '&' '*' '+' '-' '.' '/' ':' '<' '=' '>' '?' '@' '^' '|' '~'] *
- { OPERATOR (Lexing.lexeme lexbuf) }
- | eof
- { EOL }
- | _
- { raise Parsing.Parse_error }
let line_buffer = Lexing.from_function read_user_input
-let loop ppf = line_loop ppf line_buffer
+let loop ppf = line_loop ppf line_buffer; stop_user_input ()
let current_duration = ref (-1L)
restart ppf
end)
| x ->
- kill_program ();
- raise x
+ cleanup x kill_program
let execute_file_if_any () =
let buffer = Buffer.create 128 in
let len = Buffer.length buffer in
if len > 0 then
let commands = Buffer.sub buffer 0 (pred len) in
- line_loop Format.std_formatter (Lexing.from_string commands)
+ line_loop Format.std_formatter (Lexing.from_string commands);
+ stop_user_input ()
let toplevel_loop () =
interactif := false;
exit 2
let _ =
- Printexc.catch (Unix.handle_unix_error main) ()
+ Unix.handle_unix_error main ()
+++ /dev/null
-/**************************************************************************/
-/* */
-/* OCaml */
-/* */
-/* Jerome Vouillon, projet Cristal, INRIA Rocquencourt */
-/* OCaml port by John Malecki and Xavier Leroy */
-/* */
-/* Copyright 1996 Institut National de Recherche en Informatique et */
-/* en Automatique. */
-/* */
-/* All rights reserved. This file is distributed under the terms of */
-/* the GNU Lesser General Public License version 2.1, with the */
-/* special exception on linking described in the file LICENSE. */
-/* */
-/**************************************************************************/
-
-%{
-
-open Int64ops
-open Input_handling
-open Longident
-open Parser_aux
-open Debugcom
-
-%}
-
-%token <string> ARGUMENT
-%token <string> LIDENT
-%token <string> UIDENT
-%token <string> OPERATOR
-%token <int64> INTEGER
-%token STAR /* * */
-%token MINUS /* - */
-%token DOT /* . */
-%token COLON /* : */
-%token HASH /* # */
-%token AT /* @ */
-%token DOLLAR /* $ */
-%token BANG /* ! */
-%token LPAREN /* ( */
-%token RPAREN /* ) */
-%token LBRACKET /* [ */
-%token RBRACKET /* ] */
-%token EOL
-
-%right DOT
-%right BANG
-
-%start argument_list_eol
-%type <string list> argument_list_eol
-
-%start argument_eol
-%type <string> argument_eol
-
-%start integer_list_eol
-%type <int list> integer_list_eol
-
-%start integer_eol
-%type <int> integer_eol
-
-%start int64_eol
-%type <int64> int64_eol
-
-%start integer
-%type <int> integer
-
-%start opt_integer_eol
-%type <int option> opt_integer_eol
-
-%start opt_signed_integer_eol
-%type <int option> opt_signed_integer_eol
-
-%start opt_signed_int64_eol
-%type <int64 option> opt_signed_int64_eol
-
-%start identifier
-%type <string> identifier
-
-%start identifier_eol
-%type <string> identifier_eol
-
-%start identifier_or_eol
-%type <string option> identifier_or_eol
-
-%start opt_identifier
-%type <string option> opt_identifier
-
-%start opt_identifier_eol
-%type <string option> opt_identifier_eol
-
-%start expression_list_eol
-%type <Parser_aux.expression list> expression_list_eol
-
-%start break_argument_eol
-%type <Parser_aux.break_arg> break_argument_eol
-
-%start list_arguments_eol
-%type <Longident.t option * int option * int option> list_arguments_eol
-
-%start end_of_line
-%type <unit> end_of_line
-
-%start longident_eol
-%type <Longident.t> longident_eol
-
-%start opt_longident
-%type <Longident.t option> opt_longident
-
-%start opt_longident_eol
-%type <Longident.t option> opt_longident_eol
-
-%%
-
-/* Raw arguments */
-
-argument_list_eol :
- ARGUMENT argument_list_eol
- { $1::$2 }
- | end_of_line
- { [] };
-
-argument_eol :
- ARGUMENT end_of_line
- { $1 };
-
-/* Integer */
-
-integer_list_eol :
- INTEGER integer_list_eol
- { (to_int $1) :: $2 }
- | end_of_line
- { [] };
-
-integer_eol :
- INTEGER end_of_line
- { to_int $1 };
-
-int64_eol :
- INTEGER end_of_line
- { $1 };
-
-integer :
- INTEGER
- { to_int $1 };
-
-opt_integer_eol :
- INTEGER end_of_line
- { Some (to_int $1) }
- | end_of_line
- { None };
-
-opt_int64_eol :
- INTEGER end_of_line
- { Some $1 }
- | end_of_line
- { None };
-
-opt_signed_integer_eol :
- MINUS integer_eol
- { Some (- $2) }
- | opt_integer_eol
- { $1 };
-
-opt_signed_int64_eol :
- MINUS int64_eol
- { Some (Int64.neg $2) }
- | opt_int64_eol
- { $1 };
-
-/* Identifiers and long identifiers */
-
-longident :
- LIDENT { Lident $1 }
- | module_path DOT LIDENT { Ldot($1, $3) }
- | OPERATOR { Lident $1 }
- | module_path DOT OPERATOR { Ldot($1, $3) }
- | module_path DOT LPAREN OPERATOR RPAREN { Ldot($1, $4) }
-;
-
-module_path :
- UIDENT { Lident $1 }
- | module_path DOT UIDENT { Ldot($1, $3) }
-;
-
-longident_eol :
- longident end_of_line { $1 };
-
-opt_longident :
- UIDENT { Some (Lident $1) }
- | LIDENT { Some (Lident $1) }
- | module_path DOT UIDENT { Some (Ldot($1, $3)) }
- | { None };
-
-opt_longident_eol :
- opt_longident end_of_line { $1 };
-
-identifier :
- LIDENT { $1 }
- | UIDENT { $1 };
-
-identifier_eol :
- identifier end_of_line { $1 };
-
-identifier_or_eol :
- identifier { Some $1 }
- | end_of_line { None };
-
-opt_identifier :
- identifier { Some $1 }
- | { None };
-
-opt_identifier_eol :
- opt_identifier end_of_line { $1 };
-
-/* Expressions */
-
-expression:
- longident { E_ident $1 }
- | STAR { E_result }
- | DOLLAR INTEGER { E_name (to_int $2) }
- | expression DOT INTEGER { E_item($1, (to_int $3)) }
- | expression DOT LBRACKET INTEGER RBRACKET { E_item($1, (to_int $4)) }
- | expression DOT LPAREN INTEGER RPAREN { E_item($1, (to_int $4)) }
- | expression DOT LIDENT { E_field($1, $3) }
- | BANG expression { E_field($2, "contents") }
- | LPAREN expression RPAREN { $2 }
-;
-
-/* Lists of expressions */
-
-expression_list_eol :
- expression expression_list_eol { $1::$2 }
- | end_of_line { [] }
-;
-
-/* Arguments for breakpoint */
-
-break_argument_eol :
- end_of_line { BA_none }
- | integer_eol { BA_pc {frag = 0; pos = $1} }
- | INTEGER COLON integer_eol { BA_pc {frag = to_int $1;
- pos = $3} }
- | expression end_of_line { BA_function $1 }
- | AT opt_longident INTEGER opt_integer_eol { BA_pos1 ($2, (to_int $3), $4)}
- | AT opt_longident HASH integer_eol { BA_pos2 ($2, $4) }
-;
-
-/* Arguments for list */
-
-list_arguments_eol :
- opt_longident integer opt_integer_eol
- { ($1, Some $2, $3) }
- | opt_longident_eol
- { ($1, None, None) };
-
-/* End of line */
-
-end_of_line :
- EOL { stop_user_input () }
-;
(*** Miscellaneous ***)
exception Out_of_range
+let cleanup e f =
+ let bt = Printexc.get_raw_backtrace () in
+ let () = f () in
+ Printexc.raise_with_backtrace e bt
+
let nothing _ = ()
(*** Operations on lists. ***)
(*** Types and exceptions. ***)
exception Out_of_range
+(* [cleanup e f x] runs evaluates [f x] and reraises [e] with its original
+ backtrace. If [f x] raises, then [e] is not raised. *)
+val cleanup : exn -> (unit -> unit) -> 'a
+
(*** Operations on lists. ***)
(* Remove an element from a list *)
connection := io_channel_of_descr sock;
Input_handling.add_file !connection (accept_connection continue);
connection_opened := true
- with x -> close sock; raise x)
+ with x -> cleanup x @@ fun () -> close sock)
with
Failure _ -> raise Toplevel
| (Unix_error _) as err -> report_error err; raise Toplevel
prerr_endline "done."
with
x ->
- kill_program();
- raise x
+ cleanup x kill_program
end
open Input_handling
open Primitives
+module Lexer = Debugger_lexer
(* Ask user a yes or no question. *)
let yes_or_no message =
if !interactif then
- let old_prompt = !current_prompt in
- try
+ let finally =
+ let old_prompt = !current_prompt in
+ fun () -> stop_user_input (); current_prompt := old_prompt
+ in
+ Fun.protect ~finally @@ fun () ->
current_prompt := message ^ " ? (y or n) ";
let answer =
let rec ask () =
let line =
string_trim (Lexer.line (Lexing.from_function read_user_input))
in
- stop_user_input ();
match (if String.length line > 0 then line.[0] else ' ') with
'y' -> true
| 'n' -> false
| _ ->
+ stop_user_input ();
print_string "Please answer y or n.";
print_newline ();
ask ()
in
ask ()
in
- current_prompt := old_prompt;
answer
- with
- x ->
- current_prompt := old_prompt;
- stop_user_input ();
- raise x
else
false
(* Execute `funct' with a trap barrier. *)
(* --- Used by `finish'. *)
let exec_with_trap_barrier trap_barrier funct =
- try
- install_trap_barrier trap_barrier;
- funct ();
- remove_trap_barrier ()
- with
- x ->
- remove_trap_barrier ();
- raise x
+ install_trap_barrier trap_barrier;
+ Fun.protect ~finally:remove_trap_barrier funct
let last_ppx = ref []
let first_objfiles = ref []
let last_objfiles = ref []
+let stop_early = ref false
(* Check validity of module name *)
let is_unit_name name =
| "stop-after" ->
let module P = Clflags.Compiler_pass in
- begin match P.of_string v with
+ let passes = P.available_pass_names ~native:!native_code in
+ begin match List.find_opt (String.equal v) passes with
| None ->
Printf.ksprintf (print_error ppf)
"bad value %s for option \"stop-after\" (expected one of: %s)"
- v (String.concat ", " P.pass_names)
- | Some pass ->
- Clflags.stop_after := Some pass;
- begin match pass with
- | P.Parsing | P.Typing ->
- compile_only := true
- end;
+ v (String.concat ", " passes)
+ | Some v ->
+ let pass = Option.get (P.of_string v) in
+ Clflags.stop_after := Some pass
end
| _ ->
if not (List.mem name !can_discard) then begin
fatal "Option -a cannot be used with .cmxa input files.";
List.iter (process_action env) (List.rev !deferred_actions);
output_name := final_output_name;
+ stop_early :=
+ !compile_only ||
+ !print_types ||
+ match !stop_after with
+ | None -> false
+ | Some p -> Clflags.Compiler_pass.is_compilation_pass p;
val last_objfiles : string list ref
val first_objfiles : string list ref
+val stop_early : bool ref
+
type filename = string
type readenv_position =
Format.(fprintf std_formatter) "%a@."
(Printtyp.printed_signature info.source_file)
sg);
- ignore (Includemod.signatures info.env sg sg);
+ ignore (Includemod.signatures info.env ~mark:Mark_both sg sg);
Typecore.force_delayed_checks ();
Warnings.check_fatal ();
tsg
|> print_if i.ppf_dump Clflags.dump_source Pprintast.structure
let typecheck_impl i parsetree =
- let always () = Stypes.dump (Some (annot i)) in
- Misc.try_finally ~always (fun () ->
- parsetree
- |> Profile.(record typing)
- (Typemod.type_implementation
- i.source_file i.output_prefix i.module_name i.env)
- |> print_if i.ppf_dump Clflags.dump_typedtree
- Printtyped.implementation_with_coercion
- )
+ parsetree
+ |> Profile.(record typing)
+ (Typemod.type_implementation
+ i.source_file i.output_prefix i.module_name i.env)
+ |> print_if i.ppf_dump Clflags.dump_typedtree
+ Printtyped.implementation_with_coercion
let implementation info ~backend =
Profile.record_call info.source_file @@ fun () ->
let initial_env () =
Ident.reinit();
+ Types.Uid.reinit();
let initially_opened_module =
if !Clflags.nopervasives then
None
if
List.length
(List.filter (fun x -> !x)
- [make_archive;make_package;compile_only;output_c_object])
+ [make_archive;make_package;stop_early;output_c_object])
> 1
then begin
let module P = Clflags.Compiler_pass in
match !stop_after with
| None ->
fatal "Please specify at most one of -pack, -a, -c, -output-obj";
- | Some (P.Parsing | P.Typing) ->
- Printf.ksprintf fatal
- "Options -i and -stop-after (%s)\
- are incompatible with -pack, -a, -output-obj"
- (String.concat "|" P.pass_names)
+ | Some ((P.Parsing | P.Typing) as p) ->
+ assert (P.is_compilation_pass p);
+ Printf.ksprintf fatal
+ "Options -i and -stop-after (%s) \
+ are incompatible with -pack, -a, -output-obj"
+ (String.concat "|"
+ (Clflags.Compiler_pass.available_pass_names ~native:false))
+ | Some P.Scheduling -> assert false (* native only *)
end;
if !make_archive then begin
Compmisc.init_path ();
revd (extracted_output));
Warnings.check_fatal ();
end
- else if not !compile_only && !objfiles <> [] then begin
+ else if not !stop_early && !objfiles <> [] then begin
let target =
if !output_c_object && not !output_complete_executable then
let s = extract_output !output_name in
;;
let mk_annot f =
- "-annot", Arg.Unit f, " Save information in <filename>.annot"
+ "-annot", Arg.Unit f, " (deprecated) Save information in <filename>.annot"
;;
let mk_binannot f =
"-function-sections", Arg.Unit err, " (option not available)"
;;
-let mk_stop_after f =
- "-stop-after", Arg.Symbol (Clflags.Compiler_pass.pass_names, f),
+let mk_stop_after ~native f =
+ "-stop-after",
+ Arg.Symbol (Clflags.Compiler_pass.available_pass_names ~native, f),
" Stop after the given compilation pass."
;;
"-dunique-ids", Arg.Unit f, " (undocumented)"
;;
+let mk_dno_locations f =
+ "-dno-locations", Arg.Unit f, " (undocumented)"
+;;
+
+let mk_dlocations f =
+ "-dlocations", Arg.Unit f, " (undocumented)"
+;;
+
let mk_dsource f =
"-dsource", Arg.Unit f, " (undocumented)"
;;
val _dno_unique_ids : unit -> unit
val _dunique_ids : unit -> unit
+ val _dno_locations : unit -> unit
+ val _dlocations : unit -> unit
+
val _dsource : unit -> unit
val _dparsetree : unit -> unit
val _dtypedtree : unit -> unit
mk_dtypes F._annot;
mk_for_pack_byt F._for_pack;
mk_g_byt F._g;
- mk_stop_after F._stop_after;
+ mk_stop_after ~native:false F._stop_after;
mk_i F._i;
mk_I F._I;
mk_impl F._impl;
mk_use_prims F._use_prims;
mk_dno_unique_ids F._dno_unique_ids;
mk_dunique_ids F._dunique_ids;
+ mk_dno_locations F._dno_locations;
+ mk_dlocations F._dlocations;
mk_dsource F._dsource;
mk_dparsetree F._dparsetree;
mk_dtypedtree F._dtypedtree;
mk_dno_unique_ids F._dno_unique_ids;
mk_dunique_ids F._dunique_ids;
+ mk_dno_locations F._dno_locations;
+ mk_dlocations F._dlocations;
mk_dsource F._dsource;
mk_dparsetree F._dparsetree;
mk_dtypedtree F._dtypedtree;
mk_for_pack_opt F._for_pack;
mk_g_opt F._g;
mk_function_sections F._function_sections;
- mk_stop_after F._stop_after;
+ mk_stop_after ~native:true F._stop_after;
mk_i F._i;
mk_I F._I;
mk_impl F._impl;
mk_match_context_rows F._match_context_rows;
mk_dno_unique_ids F._dno_unique_ids;
mk_dunique_ids F._dunique_ids;
+ mk_dno_locations F._dno_locations;
+ mk_dlocations F._dlocations;
mk_dsource F._dsource;
mk_dparsetree F._dparsetree;
mk_dtypedtree F._dtypedtree;
let _I dir = include_dirs := (dir :: (!include_dirs))
let _color = Misc.set_or_ignore color_reader.parse color
let _dlambda = set dump_lambda
- let _dno_unique_ids = clear unique_ids
let _dparsetree = set dump_parsetree
let _drawlambda = set dump_rawlambda
let _dsource = set dump_source
let _dtypedtree = set dump_typedtree
let _dunique_ids = set unique_ids
+ let _dno_unique_ids = clear unique_ids
+ let _dlocations = set locations
+ let _dno_locations = clear locations
let _error_style =
Misc.set_or_ignore error_style_reader.parse error_style
let _nopervasives = set nopervasives
let _dump_into_file = set dump_into_file
let _for_pack s = for_package := (Some s)
let _g = set debug
- let _i () =
- print_types := true;
- compile_only := true;
- stop_after := (Some Compiler_pass.Typing);
- ()
+ let _i = set print_types
let _impl = impl
let _intf = intf
let _intf_suffix s = Config.interface_suffix := s
match P.of_string pass with
| None -> () (* this should not occur as we use Arg.Symbol *)
| Some pass ->
- stop_after := (Some pass);
- match pass with
- | P.Parsing | P.Typing -> compile_only := true
+ match !stop_after with
+ | None -> stop_after := (Some pass)
+ | Some p ->
+ if not (p = pass) then
+ fatal "Please specify at most one -stop-after <pass>."
let _thread = set use_threads
let _verbose = set verbose
let _version () = print_version_string ()
val _dno_unique_ids : unit -> unit
val _dunique_ids : unit -> unit
+ val _dno_locations : unit -> unit
+ val _dlocations : unit -> unit
val _dsource : unit -> unit
val _dparsetree : unit -> unit
val _dtypedtree : unit -> unit
let raw_dependencies = ref false
let sort_files = ref false
let all_dependencies = ref false
+let nocwd = ref false
let one_line = ref false
let files =
ref ([] : (string * file_kind * String.Set.t * string list) list)
let bound_vars =
List.fold_left
(fun bv modname ->
- Depend.open_module bv (Longident.parse modname))
+ let lid =
+ let lexbuf = Lexing.from_string modname in
+ Location.init lexbuf
+ (Printf.sprintf "command line argument: -open %S" modname);
+ Parse.simple_module_path lexbuf in
+ Depend.open_module bv lid)
!module_map ((* PR#7248 *) List.rev !Clflags.open_modules)
in
let r = extract_function bound_vars ast in
let process_file_as process_fun def source_file =
Compenv.readenv ppf (Before_compile source_file);
load_path := [];
+ let cwd = if !nocwd then [] else [Filename.current_dir_name] in
List.iter add_to_load_path (
(!Compenv.last_include_dirs @
!Clflags.include_dirs @
- !Compenv.first_include_dirs
+ !Compenv.first_include_dirs @
+ cwd
));
Location.input_name := source_file;
try
let main () =
Clflags.classic := false;
- add_to_list first_include_dirs Filename.current_dir_name;
Compenv.readenv ppf Before_args;
Clflags.reset_arguments (); (* reset arguments from ocamlc/ocamlopt *)
Clflags.add_arguments __LOC__ [
" Dump the delayed dependency map for each map file";
"-I", Arg.String (add_to_list Clflags.include_dirs),
"<dir> Add <dir> to the list of include directories";
+ "-nocwd", Arg.Set nocwd,
+ " Do not add current working directory to \
+ the list of include directories";
"-impl", Arg.String (file_dependencies_as ML),
"<f> Process <f> as a .ml file";
"-intf", Arg.String (file_dependencies_as MLI),
if
List.length (List.filter (fun x -> !x)
[make_package; make_archive; shared;
- compile_only; output_c_object]) > 1
+ stop_early; output_c_object]) > 1
then
- fatal "Please specify at most one of -pack, -a, -shared, -c, \
+ begin
+ let module P = Clflags.Compiler_pass in
+ match !stop_after with
+ | None ->
+ fatal "Please specify at most one of -pack, -a, -shared, -c, \
-output-obj";
+ | Some ((P.Parsing | P.Typing | P.Scheduling) as p) ->
+ assert (P.is_compilation_pass p);
+ Printf.ksprintf fatal
+ "Options -i and -stop-after (%s) \
+ are incompatible with -pack, -a, -shared, -output-obj"
+ (String.concat "|"
+ (Clflags.Compiler_pass.available_pass_names ~native:true))
+ end;
if !make_archive then begin
Compmisc.init_path ();
let target = extract_output !output_name in
(get_objfiles ~with_ocamlparam:false) target);
Warnings.check_fatal ();
end
- else if not !compile_only && !objfiles <> [] then begin
+ else if not !stop_early && !objfiles <> [] then begin
let target =
if !output_c_object then
let s = extract_output !output_name in
tast_iterator tast_mapper cmt_format untypeast includemod
typetexp printpat parmatch stypes typedecl typeopt rec_check typecore
typeclass typemod typedecl_variance typedecl_properties typedecl_immediacy
- typedecl_unboxed
+ typedecl_unboxed typedecl_separability cmt2annot
; manual update: mli only files
annot outcometree
exception Error of error
+(* these type abbreviations are not exported;
+ they are used to provide consistency across
+ input_value and output_value usage. *)
+type signature = Types.signature_item list
+type flags = pers_flags list
+type header = modname * signature
+
type cmi_infos = {
- cmi_name : Misc.modname;
- cmi_sign : Types.signature_item list;
+ cmi_name : modname;
+ cmi_sign : signature;
cmi_crcs : crcs;
- cmi_flags : pers_flags list;
+ cmi_flags : flags;
}
let input_cmi ic =
- let (name, sign) = input_value ic in
- let crcs = input_value ic in
- let flags = input_value ic in
+ let (name, sign) = (input_value ic : header) in
+ let crcs = (input_value ic : crcs) in
+ let flags = (input_value ic : flags) in
{
cmi_name = name;
cmi_sign = sign;
let output_cmi filename oc cmi =
(* beware: the provided signature must have been substituted for saving *)
output_string oc Config.cmi_magic_number;
- output_value oc (cmi.cmi_name, cmi.cmi_sign);
+ output_value oc ((cmi.cmi_name, cmi.cmi_sign) : header);
flush oc;
let crc = Digest.file filename in
let crcs = (cmi.cmi_name, Some crc) :: cmi.cmi_crcs in
- output_value oc crcs;
- output_value oc cmi.cmi_flags;
+ output_value oc (crcs : crcs);
+ output_value oc (cmi.cmi_flags : flags);
crc
(* Error report *)
type library =
{ lib_units: compilation_unit list; (* List of compilation units *)
lib_custom: bool; (* Requires custom mode linking? *)
+ (* In the following fields the lists are reversed with respect to
+ how they end up being used on the command line. *)
lib_ccobjs: string list; (* C object files needed for -custom *)
lib_ccopts: string list; (* Extra opts to C compiler *)
lib_dllibs: string list } (* DLLs needed *)
| Partial_structure of structure
| Partial_structure_item of structure_item
| Partial_expression of expression
-| Partial_pattern of pattern
+| Partial_pattern : 'k pattern_category * 'k general_pattern -> binary_part
| Partial_class_expr of class_expr
| Partial_signature of signature
| Partial_signature_item of signature_item
| Partial_structure_item s ->
Partial_structure_item (cenv.structure_item cenv s)
| Partial_expression e -> Partial_expression (cenv.expr cenv e)
- | Partial_pattern p -> Partial_pattern (cenv.pat cenv p)
+ | Partial_pattern (category, p) -> Partial_pattern (category, cenv.pat cenv p)
| Partial_class_expr ce -> Partial_class_expr (cenv.class_expr cenv ce)
| Partial_signature s -> Partial_signature (cenv.signature cenv s)
| Partial_signature_item s ->
| Partial_structure of structure
| Partial_structure_item of structure_item
| Partial_expression of expression
- | Partial_pattern of pattern
+ | Partial_pattern : 'k pattern_category * 'k general_pattern -> binary_part
| Partial_class_expr of class_expr
| Partial_signature of signature
| Partial_signature_item of signature_item
type library_infos =
{ lib_units: (unit_infos * Digest.t) list; (* List of unit infos w/ MD5s *)
+ (* In the following fields the lists are reversed with respect to
+ how they end up being used on the command line. *)
lib_ccobjs: string list; (* C object files needed *)
lib_ccopts: string list } (* Extra opts to C compiler *)
open Lexing
open Location
+module Scoped_location = struct
+ type scope_item =
+ | Sc_anonymous_function
+ | Sc_value_definition of string
+ | Sc_module_definition of string
+ | Sc_class_definition of string
+ | Sc_method_definition of string
+
+ type scopes = scope_item list
+
+ let add_parens_if_symbolic = function
+ | "" -> ""
+ | s ->
+ match s.[0] with
+ | 'a'..'z' | 'A'..'Z' | '_' | '0'..'9' -> s
+ | _ -> "(" ^ s ^ ")"
+
+ let string_of_scope_item = function
+ | Sc_anonymous_function ->
+ "(fun)"
+ | Sc_value_definition name
+ | Sc_module_definition name
+ | Sc_class_definition name
+ | Sc_method_definition name ->
+ add_parens_if_symbolic name
+
+ let string_of_scopes scopes =
+ let dot acc =
+ match acc with
+ | [] -> []
+ | acc -> "." :: acc in
+ let rec to_strings acc = function
+ | [] -> acc
+ (* Collapse nested anonymous function scopes *)
+ | Sc_anonymous_function :: ((Sc_anonymous_function :: _) as rest) ->
+ to_strings acc rest
+ (* Use class#meth syntax for classes *)
+ | (Sc_method_definition _ as meth) ::
+ (Sc_class_definition _ as cls) :: rest ->
+ to_strings (string_of_scope_item cls :: "#" ::
+ string_of_scope_item meth :: dot acc) rest
+ | s :: rest ->
+ to_strings (string_of_scope_item s :: dot acc) rest in
+ match scopes with
+ | [] -> "<unknown>"
+ | scopes -> String.concat "" (to_strings [] scopes)
+
+ let enter_anonymous_function ~scopes =
+ Sc_anonymous_function :: scopes
+ let enter_value_definition ~scopes id =
+ Sc_value_definition (Ident.name id) :: scopes
+ let enter_module_definition ~scopes id =
+ Sc_module_definition (Ident.name id) :: scopes
+ let enter_class_definition ~scopes id =
+ Sc_class_definition (Ident.name id) :: scopes
+ let enter_method_definition ~scopes (m : Asttypes.label) =
+ Sc_method_definition m :: scopes
+
+ type t =
+ | Loc_unknown
+ | Loc_known of
+ { loc : Location.t;
+ scopes : scopes; }
+
+ let of_location ~scopes loc =
+ if Location.is_none loc then
+ Loc_unknown
+ else
+ Loc_known { loc; scopes }
+
+ let to_location = function
+ | Loc_unknown -> Location.none
+ | Loc_known { loc; _ } -> loc
+
+ let string_of_scoped_location = function
+ | Loc_unknown -> "??"
+ | Loc_known { loc = _; scopes } -> string_of_scopes scopes
+end
+
type item = {
dinfo_file: string;
dinfo_line: int;
dinfo_start_bol: int;
dinfo_end_bol: int;
dinfo_end_line: int;
+ dinfo_scopes: Scoped_location.scopes;
}
type t = item list
+type alloc_dbginfo_item =
+ { alloc_words : int;
+ alloc_dbg : t }
+type alloc_dbginfo = alloc_dbginfo_item list
+
let none = []
let is_none = function
in
"{" ^ String.concat ";" items ^ "}"
-let item_from_location loc =
+let item_from_location ~scopes loc =
let valid_endpos =
String.equal loc.loc_end.pos_fname loc.loc_start.pos_fname in
{ dinfo_file = loc.loc_start.pos_fname;
dinfo_end_line =
if valid_endpos then loc.loc_end.pos_lnum
else loc.loc_start.pos_lnum;
+ dinfo_scopes = scopes
}
-let from_location loc =
- if loc == Location.none then [] else [item_from_location loc]
+let from_location = function
+ | Scoped_location.Loc_unknown -> []
+ | Scoped_location.Loc_known {scopes; loc} ->
+ assert (not (Location.is_none loc));
+ [item_from_location ~scopes loc]
let to_location = function
| [] -> Location.none
} in
{ loc_ghost = false; loc_start; loc_end; }
-let inline loc t =
- if loc == Location.none then t
- else (item_from_location loc) :: t
-
-let concat dbg1 dbg2 =
+let inline dbg1 dbg2 =
dbg1 @ dbg2
(* CR-someday afrisch: FWIW, the current compare function does not seem very
(* *)
(**************************************************************************)
+module Scoped_location : sig
+ type scope_item =
+ | Sc_anonymous_function
+ | Sc_value_definition of string
+ | Sc_module_definition of string
+ | Sc_class_definition of string
+ | Sc_method_definition of string
+
+ type scopes = scope_item list
+ val string_of_scope_item : scope_item -> string
+ val string_of_scopes : scopes -> string
+
+ val enter_anonymous_function : scopes:scopes -> scopes
+ val enter_value_definition : scopes:scopes -> Ident.t -> scopes
+ val enter_module_definition : scopes:scopes -> Ident.t -> scopes
+ val enter_class_definition : scopes:scopes -> Ident.t -> scopes
+ val enter_method_definition : scopes:scopes -> Asttypes.label -> scopes
+
+ type t =
+ | Loc_unknown
+ | Loc_known of
+ { loc : Location.t;
+ scopes : scopes; }
+
+ val of_location : scopes:scopes -> Location.t -> t
+ val to_location : t -> Location.t
+ val string_of_scoped_location : t -> string
+end
+
type item = private {
dinfo_file: string;
dinfo_line: int;
dinfo_start_bol: int;
dinfo_end_bol: int;
dinfo_end_line: int;
+ dinfo_scopes: Scoped_location.scopes;
}
type t = item list
+type alloc_dbginfo_item =
+ { alloc_words : int;
+ alloc_dbg : t }
+(** Due to Comballoc, a single Ialloc instruction may combine several
+ unrelated allocations. Their Debuginfo.t (which may differ) are stored
+ as a list of alloc_dbginfo. This list is in order of increasing memory
+ address, which is the reverse of the original allocation order. Later
+ allocations are consed to the front of this list by Comballoc. *)
+
+type alloc_dbginfo = alloc_dbginfo_item list
+
val none : t
val is_none : t -> bool
val to_string : t -> string
-val from_location : Location.t -> t
+val from_location : Scoped_location.t -> t
val to_location : t -> Location.t
-val concat: t -> t -> t
-
-val inline: Location.t -> t -> t
+val inline : t -> t -> t
val compare : t -> t -> int
| Pandint | Porint | Pxorint
| Plslint | Plsrint | Pasrint
| Pintcomp of integer_comparison
+ | Pcompare_ints | Pcompare_floats | Pcompare_bints of boxed_integer
| Poffsetint of int
| Poffsetref of int
(* Float operations *)
type inline_attribute =
| Always_inline (* [@inline] or [@inline always] *)
| Never_inline (* [@inline never] *)
+ | Hint_inline (* [@inlined hint] attribute *)
| Unroll of int (* [@unroll x] *)
| Default_inline (* no [@inline] attribute *)
match x, y with
| Always_inline, Always_inline
| Never_inline, Never_inline
+ | Hint_inline, Hint_inline
| Default_inline, Default_inline
->
true
| Unroll u, Unroll v ->
u = v
- | (Always_inline | Never_inline | Unroll _ | Default_inline), _ ->
+ | (Always_inline | Never_inline
+ | Hint_inline | Unroll _ | Default_inline), _ ->
false
type specialise_attribute =
stub: bool;
}
+type scoped_location = Debuginfo.Scoped_location.t
+
type lambda =
Lvar of Ident.t
| Lconst of structured_constant
| Lfunction of lfunction
| Llet of let_kind * value_kind * Ident.t * lambda * lambda
| Lletrec of (Ident.t * lambda) list * lambda
- | Lprim of primitive * lambda list * Location.t
- | Lswitch of lambda * lambda_switch * Location.t
+ | Lprim of primitive * lambda list * scoped_location
+ | Lswitch of lambda * lambda_switch * scoped_location
| Lstringswitch of
- lambda * (string * lambda) list * lambda option * Location.t
+ lambda * (string * lambda) list * lambda option * scoped_location
| Lstaticraise of int * lambda list
| Lstaticcatch of lambda * (int * (Ident.t * value_kind) list) * lambda
| Ltrywith of lambda * Ident.t * lambda
| Lwhile of lambda * lambda
| Lfor of Ident.t * lambda * lambda * direction_flag * lambda
| Lassign of Ident.t * lambda
- | Lsend of meth_kind * lambda * lambda * lambda list * Location.t
+ | Lsend of meth_kind * lambda * lambda * lambda list * scoped_location
| Levent of lambda * lambda_event
| Lifused of Ident.t * lambda
return: value_kind;
body: lambda;
attr: function_attribute; (* specified with [@inline] attribute *)
- loc: Location.t; }
+ loc: scoped_location; }
and lambda_apply =
{ ap_func : lambda;
ap_args : lambda list;
- ap_loc : Location.t;
+ ap_loc : scoped_location;
ap_should_be_tailcall : bool;
ap_inlined : inline_attribute;
ap_specialised : specialise_attribute; }
sw_failaction : lambda option}
and lambda_event =
- { lev_loc: Location.t;
+ { lev_loc: scoped_location;
lev_kind: lambda_event_kind;
lev_repr: int ref option;
lev_env: Env.t }
| Lapply ap ->
Lapply {ap with ap_func = tr_rec env ap.ap_func;
ap_args = tr_recs env ap.ap_args;
- ap_loc = Location.none}
+ ap_loc = Loc_unknown}
| Llet (Alias,_k,x,ex,e) -> (* Ignore aliases -> substitute *)
let ex = tr_rec env ex in
tr_rec (Ident.add x ex env) e
let y = make_key x in
Llet (str,k,y,ex,tr_rec (Ident.add x (Lvar y) env) e)
| Lprim (p,es,_) ->
- Lprim (p,tr_recs env es, Location.none)
+ Lprim (p,tr_recs env es, Loc_unknown)
| Lswitch (e,sw,loc) ->
Lswitch (tr_rec env e,tr_sw env sw,loc)
| Lstringswitch (e,sw,d,_) ->
(tr_rec env e,
List.map (fun (s,e) -> s,tr_rec env e) sw,
tr_opt env d,
- Location.none)
+ Loc_unknown)
| Lstaticraise (i,es) ->
Lstaticraise (i,tr_recs env es)
| Lstaticcatch (e1,xs,e2) ->
| Lassign (x,e) ->
Lassign (x,tr_rec env e)
| Lsend (m,e1,e2,es,_loc) ->
- Lsend (m,tr_rec env e1,tr_rec env e2,tr_recs env es,Location.none)
+ Lsend (m,tr_rec env e1,tr_rec env e2,tr_recs env es,Loc_unknown)
| Lifused (id,e) -> Lifused (id,tr_rec env e)
| Lletrec _|Lfunction _
| Lfor _ | Lwhile _
let env = Env.add_persistent_structure pers Env.empty in
let lid = Longident.Ldot (Longident.Lident mod_name, name) in
match Env.find_value_by_name lid env with
- | path, _ -> transl_value_path Location.none env path
+ | path, _ -> transl_value_path Loc_unknown env path
| exception Not_found ->
fatal_error ("Primitive " ^ name ^ " not found.")
| Pandint | Porint | Pxorint
| Plslint | Plsrint | Pasrint
| Pintcomp of integer_comparison
+ (* Comparions that return int (not bool like above) for ordering *)
+ | Pcompare_ints | Pcompare_floats | Pcompare_bints of boxed_integer
| Poffsetint of int
| Poffsetref of int
(* Float operations *)
type inline_attribute =
| Always_inline (* [@inline] or [@inline always] *)
| Never_inline (* [@inline never] *)
+ | Hint_inline (* [@inline hint] *)
| Unroll of int (* [@unroll x] *)
| Default_inline (* no [@inline] attribute *)
stub: bool;
}
+type scoped_location = Debuginfo.Scoped_location.t
+
type lambda =
Lvar of Ident.t
| Lconst of structured_constant
| Lfunction of lfunction
| Llet of let_kind * value_kind * Ident.t * lambda * lambda
| Lletrec of (Ident.t * lambda) list * lambda
- | Lprim of primitive * lambda list * Location.t
- | Lswitch of lambda * lambda_switch * Location.t
+ | Lprim of primitive * lambda list * scoped_location
+ | Lswitch of lambda * lambda_switch * scoped_location
(* switch on strings, clauses are sorted by string order,
strings are pairwise distinct *)
| Lstringswitch of
- lambda * (string * lambda) list * lambda option * Location.t
+ lambda * (string * lambda) list * lambda option * scoped_location
| Lstaticraise of int * lambda list
| Lstaticcatch of lambda * (int * (Ident.t * value_kind) list) * lambda
| Ltrywith of lambda * Ident.t * lambda
| Lwhile of lambda * lambda
| Lfor of Ident.t * lambda * lambda * direction_flag * lambda
| Lassign of Ident.t * lambda
- | Lsend of meth_kind * lambda * lambda * lambda list * Location.t
+ | Lsend of meth_kind * lambda * lambda * lambda list * scoped_location
| Levent of lambda * lambda_event
| Lifused of Ident.t * lambda
return: value_kind;
body: lambda;
attr: function_attribute; (* specified with [@inline] attribute *)
- loc : Location.t; }
+ loc : scoped_location; }
and lambda_apply =
{ ap_func : lambda;
ap_args : lambda list;
- ap_loc : Location.t;
+ ap_loc : scoped_location;
ap_should_be_tailcall : bool; (* true if [@tailcall] was specified *)
ap_inlined : inline_attribute; (* specified with the [@inlined] attribute *)
ap_specialised : specialise_attribute; }
sw_blocks: (int * lambda) list; (* Tag block cases *)
sw_failaction : lambda option} (* Action to take if failure *)
and lambda_event =
- { lev_loc: Location.t;
+ { lev_loc: scoped_location;
lev_kind: lambda_event_kind;
lev_repr: int ref option;
lev_env: Env.t }
val free_variables: lambda -> Ident.Set.t
-val transl_module_path: Location.t -> Env.t -> Path.t -> lambda
-val transl_value_path: Location.t -> Env.t -> Path.t -> lambda
-val transl_extension_path: Location.t -> Env.t -> Path.t -> lambda
-val transl_class_path: Location.t -> Env.t -> Path.t -> lambda
+val transl_module_path: scoped_location -> Env.t -> Path.t -> lambda
+val transl_value_path: scoped_location -> Env.t -> Path.t -> lambda
+val transl_extension_path: scoped_location -> Env.t -> Path.t -> lambda
+val transl_class_path: scoped_location -> Env.t -> Path.t -> lambda
val make_sequence: ('a -> lambda) -> 'a list -> lambda
open Parmatch
open Printf
open Printpat
+open Debuginfo.Scoped_location
let dbg = false
Array.to_list t
| _ -> fatal_error "Matching.all_record_args"
+type 'a clause = 'a * lambda
+
+module Non_empty_clause = struct
+ type 'a t = ('a * Typedtree.pattern list) clause
+
+ let of_initial = function
+ | [], _ -> assert false
+ | pat :: patl, act -> ((pat, patl), act)
+
+ let map_head f ((p, patl), act) = ((f p, patl), act)
+end
+
+type simple_view =
+ [ `Any
+ | `Constant of constant
+ | `Tuple of pattern list
+ | `Construct of Longident.t loc * constructor_description * pattern list
+ | `Variant of label * pattern option * row_desc ref
+ | `Record of
+ (Longident.t loc * label_description * pattern) list * closed_flag
+ | `Array of pattern list
+ | `Lazy of pattern ]
+
+type half_simple_view =
+ [ simple_view | `Or of pattern * pattern * row_desc option ]
+
+type general_view =
+ [ half_simple_view
+ | `Var of Ident.t * string loc
+ | `Alias of pattern * Ident.t * string loc ]
+
+module General : sig
+ type pattern = general_view pattern_data
+
+ type clause = pattern Non_empty_clause.t
+
+ val view : Typedtree.pattern -> pattern
+
+ val erase : [< general_view ] pattern_data -> Typedtree.pattern
+end = struct
+ type pattern = general_view pattern_data
+
+ type clause = pattern Non_empty_clause.t
+
+ let view_desc = function
+ | Tpat_any -> `Any
+ | Tpat_var (id, str) -> `Var (id, str)
+ | Tpat_alias (p, id, str) -> `Alias (p, id, str)
+ | Tpat_constant cst -> `Constant cst
+ | Tpat_tuple ps -> `Tuple ps
+ | Tpat_construct (cstr, cstr_descr, args) ->
+ `Construct (cstr, cstr_descr, args)
+ | Tpat_variant (cstr, arg, row_desc) -> `Variant (cstr, arg, row_desc)
+ | Tpat_record (fields, closed) -> `Record (fields, closed)
+ | Tpat_array ps -> `Array ps
+ | Tpat_or (p, q, row_desc) -> `Or (p, q, row_desc)
+ | Tpat_lazy p -> `Lazy p
+
+ let view p : pattern = { p with pat_desc = view_desc p.pat_desc }
+
+ let erase_desc = function
+ | `Any -> Tpat_any
+ | `Var (id, str) -> Tpat_var (id, str)
+ | `Alias (p, id, str) -> Tpat_alias (p, id, str)
+ | `Constant cst -> Tpat_constant cst
+ | `Tuple ps -> Tpat_tuple ps
+ | `Construct (cstr, cst_descr, args) ->
+ Tpat_construct (cstr, cst_descr, args)
+ | `Variant (cstr, arg, row_desc) -> Tpat_variant (cstr, arg, row_desc)
+ | `Record (fields, closed) -> Tpat_record (fields, closed)
+ | `Array ps -> Tpat_array ps
+ | `Or (p, q, row_desc) -> Tpat_or (p, q, row_desc)
+ | `Lazy p -> Tpat_lazy p
+
+ let erase p = { p with pat_desc = erase_desc p.pat_desc }
+end
+
+module Half_simple : sig
+ (** Half-simplified patterns are patterns where:
+ - records are expanded so that they possess all fields
+ - aliases are removed and replaced by bindings in actions.
+
+ Or-patterns are not removed, they are only "half-simplified":
+ - aliases under or-patterns are kept
+ - or-patterns whose right-hand-side is subsumed by their lhs
+ are simplified to their lhs.
+ For instance: [(_ :: _ | 1 :: _)] is changed into [_ :: _]
+ - or-patterns whose left-hand-side is not simplified
+ are preserved: (p|q) is changed into (simpl(p)|simpl(q))
+ {v
+ # match lazy (print_int 3; 3) with _ | lazy 2 -> ();;
+ - : unit = ()
+ # match lazy (print_int 3; 3) with lazy 2 | _ -> ();;
+ 3- : unit = ()
+ v}
+
+ In particular, or-patterns may still occur in the leading column,
+ so this is only a "half-simplification". *)
+
+ type pattern = half_simple_view pattern_data
+
+ type clause = pattern Non_empty_clause.t
+
+ val of_clause : arg:lambda -> General.clause -> clause
+end = struct
+ type pattern = half_simple_view pattern_data
+
+ type clause = pattern Non_empty_clause.t
+
+ let rec simpl_under_orpat p =
+ match p.pat_desc with
+ | Tpat_any
+ | Tpat_var _ ->
+ p
+ | Tpat_alias (q, id, s) ->
+ { p with pat_desc = Tpat_alias (simpl_under_orpat q, id, s) }
+ | Tpat_or (p1, p2, o) ->
+ let p1, p2 = (simpl_under_orpat p1, simpl_under_orpat p2) in
+ if le_pat p1 p2 then
+ p1
+ else
+ { p with pat_desc = Tpat_or (p1, p2, o) }
+ | Tpat_record (lbls, closed) ->
+ let all_lbls = all_record_args lbls in
+ { p with pat_desc = Tpat_record (all_lbls, closed) }
+ | _ -> p
+
+ (* Explode or-patterns and turn aliases into bindings in actions *)
+ let of_clause ~arg cl =
+ let rec aux (((p, patl), action) : General.clause) : clause =
+ let continue p (view : general_view) : clause =
+ aux (({ p with pat_desc = view }, patl), action)
+ in
+ let stop p (view : half_simple_view) : clause =
+ (({ p with pat_desc = view }, patl), action)
+ in
+ match p.pat_desc with
+ | `Any -> stop p `Any
+ | `Var (id, s) -> continue p (`Alias (omega, id, s))
+ | `Alias (p, id, _) ->
+ let k = Typeopt.value_kind p.pat_env p.pat_type in
+ aux
+ ( (General.view p, patl),
+ bind_with_value_kind Alias (id, k) arg action )
+ | `Record ([], _) as view -> stop p view
+ | `Record (lbls, closed) ->
+ let full_view = `Record (all_record_args lbls, closed) in
+ stop p full_view
+ | `Or _ -> (
+ let orpat = General.view (simpl_under_orpat (General.erase p)) in
+ match orpat.pat_desc with
+ | `Or _ as or_view -> stop orpat or_view
+ | other_view -> continue orpat other_view
+ )
+ | ( `Constant _ | `Tuple _ | `Construct _ | `Variant _ | `Array _
+ | `Lazy _ ) as view ->
+ stop p view
+ in
+ aux cl
+end
+
+exception Cannot_flatten
+
+module Simple : sig
+ type pattern = simple_view pattern_data
+
+ type clause = pattern Non_empty_clause.t
+
+ val head : pattern -> Pattern_head.t
+
+ val explode_or_pat :
+ Half_simple.pattern * Typedtree.pattern list ->
+ arg:Ident.t option ->
+ mk_action:(vars:Ident.t list -> lambda) ->
+ vars:Ident.t list ->
+ clause list ->
+ clause list
+end = struct
+ type pattern = simple_view pattern_data
+
+ type clause = pattern Non_empty_clause.t
+
+ let head p =
+ fst (Pattern_head.deconstruct (General.erase (p :> General.pattern)))
+
+ let alpha env (p : pattern) : pattern =
+ let alpha_pat env p = Typedtree.alpha_pat env p in
+ let pat_desc =
+ match p.pat_desc with
+ | `Any -> `Any
+ | `Constant cst -> `Constant cst
+ | `Tuple ps -> `Tuple (List.map (alpha_pat env) ps)
+ | `Construct (cstr, cst_descr, args) ->
+ `Construct (cstr, cst_descr, List.map (alpha_pat env) args)
+ | `Variant (cstr, argo, row_desc) ->
+ `Variant (cstr, Option.map (alpha_pat env) argo, row_desc)
+ | `Record (fields, closed) ->
+ let alpha_field env (lid, l, p) = (lid, l, alpha_pat env p) in
+ `Record (List.map (alpha_field env) fields, closed)
+ | `Array ps -> `Array (List.map (alpha_pat env) ps)
+ | `Lazy p -> `Lazy (alpha_pat env p)
+ in
+ { p with pat_desc }
+
+ let mk_alpha_env arg aliases ids =
+ List.map
+ (fun id ->
+ ( id,
+ if List.mem id aliases then
+ match arg with
+ | Some v -> v
+ | _ -> raise Cannot_flatten
+ else
+ Ident.create_local (Ident.name id) ))
+ ids
+
+ let explode_or_pat ((p : Half_simple.pattern), patl) ~arg ~mk_action ~vars
+ (rem : clause list) : clause list =
+ let rec explode p aliases rem =
+ let split_explode p aliases rem = explode (General.view p) aliases rem in
+ match p.pat_desc with
+ | `Or (p1, p2, _) ->
+ split_explode p1 aliases (split_explode p2 aliases rem)
+ | `Alias (p, id, _) -> split_explode p (id :: aliases) rem
+ | `Var (id, str) ->
+ explode
+ { p with pat_desc = `Alias (Parmatch.omega, id, str) }
+ aliases rem
+ | #simple_view as view ->
+ let env = mk_alpha_env arg aliases vars in
+ ( (alpha env { p with pat_desc = view }, patl),
+ mk_action ~vars:(List.map snd env) )
+ :: rem
+ in
+ explode (p : Half_simple.pattern :> General.pattern) [] rem
+end
+
+type initial_clause = pattern list clause
+
type matrix = pattern list list
let add_omega_column pss = List.map (fun ps -> omega :: ps) pss
let combine ctx = List.map Row.combine ctx
- let ctx_matcher p =
- let p = normalize_pat p in
- match p.pat_desc with
- | Tpat_construct (_, cstr, omegas) -> (
- fun q rem ->
- match q.pat_desc with
- | Tpat_construct (_, cstr', args)
- (* NB: may_constr_equal considers (potential) constructor rebinding *)
- when Types.may_equal_constr cstr cstr' ->
- (p, args @ rem)
- | Tpat_any -> (p, omegas @ rem)
- | _ -> raise NoMatch
- )
- | Tpat_constant cst -> (
- fun q rem ->
- match q.pat_desc with
- | Tpat_constant cst' when const_compare cst cst' = 0 -> (p, rem)
- | Tpat_any -> (p, rem)
- | _ -> raise NoMatch
- )
- | Tpat_variant (lab, Some omega, _) -> (
- fun q rem ->
- match q.pat_desc with
- | Tpat_variant (lab', Some arg, _) when lab = lab' -> (p, arg :: rem)
- | Tpat_any -> (p, omega :: rem)
- | _ -> raise NoMatch
- )
- | Tpat_variant (lab, None, _) -> (
- fun q rem ->
- match q.pat_desc with
- | Tpat_variant (lab', None, _) when lab = lab' -> (p, rem)
- | Tpat_any -> (p, rem)
- | _ -> raise NoMatch
- )
- | Tpat_array omegas -> (
- let len = List.length omegas in
- fun q rem ->
- match q.pat_desc with
- | Tpat_array args when List.length args = len -> (p, args @ rem)
- | Tpat_any -> (p, omegas @ rem)
- | _ -> raise NoMatch
- )
- | Tpat_tuple omegas -> (
- let len = List.length omegas in
- fun q rem ->
- match q.pat_desc with
- | Tpat_tuple args when List.length args = len -> (p, args @ rem)
- | Tpat_any -> (p, omegas @ rem)
- | _ -> raise NoMatch
- )
- | Tpat_record (((_, lbl, _) :: _ as l), _) -> (
- (* Records are normalized *)
- let len = Array.length lbl.lbl_all in
- fun q rem ->
- match q.pat_desc with
- | Tpat_record (((_, lbl', _) :: _ as l'), _)
- when Array.length lbl'.lbl_all = len ->
- let l' = all_record_args l' in
- (p, List.fold_right (fun (_, _, p) r -> p :: r) l' rem)
- | Tpat_any -> (p, List.fold_right (fun (_, _, p) r -> p :: r) l rem)
- | _ -> raise NoMatch
- )
- | Tpat_lazy omega -> (
- fun q rem ->
- match q.pat_desc with
- | Tpat_lazy arg -> (p, arg :: rem)
- | Tpat_any -> (p, omega :: rem)
- | _ -> raise NoMatch
- )
- | _ -> fatal_error "Matching.Context.matcher"
+ let ctx_matcher p q rem =
+ let rec expand_record p =
+ match p.pat_desc with
+ | Tpat_record (l, _) ->
+ { p with pat_desc = Tpat_record (all_record_args l, Closed) }
+ | Tpat_alias (p, _, _) -> expand_record p
+ | _ -> p
+ in
+ let ph, omegas =
+ let ph, p_args = Pattern_head.deconstruct (expand_record p) in
+ (ph, List.map (fun _ -> omega) p_args)
+ in
+ let qh, args = Pattern_head.deconstruct (expand_record q) in
+ let yes () = (p, args @ rem) in
+ let no () = raise NoMatch in
+ let yesif b =
+ if b then
+ yes ()
+ else
+ no ()
+ in
+ match (Pattern_head.desc ph, Pattern_head.desc qh) with
+ | Any, _ -> fatal_error "Matching.Context.matcher"
+ | _, Any -> (p, omegas @ rem)
+ | Construct cstr, Construct cstr' ->
+ (* NB: may_equal_constr considers (potential) constructor rebinding *)
+ yesif (Types.may_equal_constr cstr cstr')
+ | Construct _, _ -> no ()
+ | Constant cst, Constant cst' -> yesif (const_compare cst cst' = 0)
+ | Constant _, _ -> no ()
+ | Variant { tag; has_arg }, Variant { tag = tag'; has_arg = has_arg' } ->
+ yesif (tag = tag' && has_arg = has_arg')
+ | Variant _, _ -> no ()
+ | Array n1, Array n2 -> yesif (n1 = n2)
+ | Array _, _ -> no ()
+ | Tuple n1, Tuple n2 -> yesif (n1 = n2)
+ | Tuple _, _ -> no ()
+ | Record l, Record l' ->
+ (* we called expand_record on both arguments so l, l' are full *)
+ yesif (List.length l = List.length l')
+ | Record _, _ -> no ()
+ | Lazy, Lazy -> yes ()
+ | Lazy, _ -> no ()
let specialize q ctx =
let matcher = ctx_matcher q in
(* Pattern matching before any compilation *)
-type pattern_matching = {
- mutable cases : (pattern list * lambda) list;
+type 'row pattern_matching = {
+ mutable cases : 'row list;
args : (lambda * let_kind) list;
(** args are not just Ident.t in at least the following cases:
- when matching the arguments of a constructor,
provenance : matrix;
exit : int;
vars : (Ident.t * Lambda.value_kind) list;
- pm : pattern_matching
+ pm : initial_clause pattern_matching
}
-type pm_or_compiled = {
- body : pattern_matching;
+type 'head_pat pm_or_compiled = {
+ body : 'head_pat Non_empty_clause.t pattern_matching;
handlers : handler list;
or_matrix : matrix
}
mixture rule *)
type pm_half_compiled =
- | PmOr of pm_or_compiled
+ | PmOr of Simple.pattern pm_or_compiled
| PmVar of { inside : pm_half_compiled }
- | Pm of pattern_matching
+ | Pm of Simple.clause pattern_matching
(* Only used inside the various split functions, we only keep [me] when we're
done splitting / precompiling. *)
top_default : Default_environment.t
}
+let erase_cases f cases =
+ List.map (fun ((p, ps), act) -> (f p :: ps, act)) cases
+
+let erase_pm pm =
+ { pm with cases = erase_cases General.erase pm.cases }
+
let pretty_cases cases =
List.iter
(fun (ps, _l) ->
let rec pretty_precompiled = function
| Pm pm ->
Format.eprintf "++++ PM ++++\n";
- pretty_pm pm
+ pretty_pm (erase_pm pm)
| PmVar x ->
Format.eprintf "++++ VAR ++++\n";
pretty_precompiled x.inside
| PmOr x ->
Format.eprintf "++++ OR ++++\n";
- pretty_pm x.body;
+ pretty_pm (erase_pm x.body);
pretty_matrix Format.err_formatter x.or_matrix;
List.iter
(fun { exit = i; pm; _ } ->
None
)
-let safe_before (ps, act_p) l =
+let safe_before ((p, ps), act_p) l =
(* Test for swapping two clauses *)
let same_actions act1 act2 =
match (make_key act1, make_key act2) with
false
in
List.for_all
- (fun (qs, act_q) -> same_actions act_p act_q || not (may_compats ps qs))
+ (fun ((q, qs), act_q) ->
+ same_actions act_p act_q
+ || not (may_compats (General.erase p :: ps) (General.erase q :: qs)))
l
-(*
- The half-simplify functions transforms the first column of the match
- - records are expanded so that they possess all fields
- - aliases are removed and replaced by bindings in actions.
-
- However or-patterns are only half-simplified,
- - aliases under or-patterns are kept
- - or-patterns whose right-hand-side is subsumed by their lhs
- are simplified to their lhs.
- For instance: [(_ :: _ | 1 :: _)] is changed into [_ :: _]
- - or-patterns whose left-hand-side is not simplified
- are preserved: (p|q) is changed into (simpl(p)|simpl(q))
- {v
- # match lazy (print_int 3; 3) with _ | lazy 2 -> ();;
- - : unit = ()
- # match lazy (print_int 3; 3) with lazy 2 | _ -> ();;
- 3- : unit = ()
- v}
-
- In particular, or-patterns may still occur in the head of the output row,
- so this is only a "half-simplification".
-*)
-let half_simplify_cases args cls =
- let rec simpl_pat p =
- match p.pat_desc with
- | Tpat_any
- | Tpat_var _ ->
- p
- | Tpat_alias (q, id, s) ->
- { p with pat_desc = Tpat_alias (simpl_pat q, id, s) }
- | Tpat_or (p1, p2, o) ->
- let p1, p2 = (simpl_pat p1, simpl_pat p2) in
- if le_pat p1 p2 then
- p1
- else
- { p with pat_desc = Tpat_or (p1, p2, o) }
- | Tpat_record (lbls, closed) ->
- let all_lbls = all_record_args lbls in
- { p with pat_desc = Tpat_record (all_lbls, closed) }
- | _ -> p
- in
- let rec simpl_clause cl =
- match cl with
- | [], _ -> assert false
- | pat :: patl, action -> (
- match pat.pat_desc with
- | Tpat_any -> cl
- | Tpat_var (id, s) ->
- let p = { pat with pat_desc = Tpat_alias (omega, id, s) } in
- simpl_clause (p :: patl, action)
- | Tpat_alias (p, id, _) ->
- let arg =
- match args with
- | [] -> assert false
- | (arg, _) :: _ -> arg
- in
- let k = Typeopt.value_kind pat.pat_env pat.pat_type in
- simpl_clause
- (p :: patl, bind_with_value_kind Alias (id, k) arg action)
- | Tpat_record ([], _) -> (omega :: patl, action)
- | Tpat_record (lbls, closed) ->
- let all_lbls = all_record_args lbls in
- let full_pat =
- { pat with pat_desc = Tpat_record (all_lbls, closed) }
- in
- (full_pat :: patl, action)
- | Tpat_or _ -> (
- let pat_simple = simpl_pat pat in
- match pat_simple.pat_desc with
- | Tpat_or _ -> (pat_simple :: patl, action)
- | _ -> simpl_clause (pat_simple :: patl, action)
- )
- | Tpat_constant _
- | Tpat_tuple _
- | Tpat_construct _
- | Tpat_variant _
- | Tpat_array _
- | Tpat_lazy _
- | Tpat_exception _ ->
- cl
- )
- in
- List.map simpl_clause cls
+let half_simplify_nonempty ~arg (cls : Typedtree.pattern Non_empty_clause.t) :
+ Half_simple.clause =
+ cls |> Non_empty_clause.map_head General.view |> Half_simple.of_clause ~arg
+
+let half_simplify_clause ~arg (cls : Typedtree.pattern list clause) =
+ cls |> Non_empty_clause.of_initial |> half_simplify_nonempty ~arg
(* Once matchings are *fully* simplified, one can easily find
their nature. *)
let rec what_is_cases ~skip_any cases =
match cases with
- | [] -> omega
- | ([], _) :: _ -> assert false
- | (p :: _, _) :: rem -> (
- match p.pat_desc with
- | Tpat_any when skip_any -> what_is_cases ~skip_any rem
- | Tpat_var _
- | Tpat_or (_, _, _)
- | Tpat_alias (_, _, _) ->
- (* applies to simplified matchings only *)
- assert false
- | _ -> p
+ | [] -> Pattern_head.omega
+ | ((p, _), _) :: rem -> (
+ let head = Simple.head p in
+ match Pattern_head.desc head with
+ | Any when skip_any -> what_is_cases ~skip_any rem
+ | _ -> head
)
let what_is_first_case = what_is_cases ~skip_any:false
let what_is_cases = what_is_cases ~skip_any:true
-(* Or-pattern expansion, variables are a complication w.r.t. the article *)
-
-exception Cannot_flatten
-
-let mk_alpha_env arg aliases ids =
- List.map
- (fun id ->
- ( id,
- if List.mem id aliases then
- match arg with
- | Some v -> v
- | _ -> raise Cannot_flatten
- else
- Ident.create_local (Ident.name id) ))
- ids
-
-let rec explode_or_pat p arg patl mk_action vars aliases rem =
- match p.pat_desc with
- | Tpat_or (p1, p2, _) ->
- explode_or_pat p1 arg patl mk_action vars aliases
- (explode_or_pat p2 arg patl mk_action vars aliases rem)
- | Tpat_alias (p, id, _) ->
- explode_or_pat p arg patl mk_action vars (id :: aliases) rem
- | Tpat_var (x, _) ->
- let env = mk_alpha_env arg (x :: aliases) vars in
- (omega :: patl, mk_action (List.map snd env)) :: rem
- | _ ->
- let env = mk_alpha_env arg aliases vars in
- (alpha_pat env p :: patl, mk_action (List.map snd env)) :: rem
-
let pm_free_variables { cases } =
List.fold_right
(fun (_, act) r -> Ident.Set.union (free_variables act) r)
| { pat_desc = Tpat_construct (_, cstr, _) } -> cstr
| _ -> fatal_error "Matching.pat_as_constr"
-let group_const_int = function
- | { pat_desc = Tpat_constant (Const_int _) } -> true
- | _ -> false
-
-let group_const_char = function
- | { pat_desc = Tpat_constant (Const_char _) } -> true
- | _ -> false
-
-let group_const_string = function
- | { pat_desc = Tpat_constant (Const_string _) } -> true
- | _ -> false
-
-let group_const_float = function
- | { pat_desc = Tpat_constant (Const_float _) } -> true
- | _ -> false
-
-let group_const_int32 = function
- | { pat_desc = Tpat_constant (Const_int32 _) } -> true
- | _ -> false
-
-let group_const_int64 = function
- | { pat_desc = Tpat_constant (Const_int64 _) } -> true
- | _ -> false
-
-let group_const_nativeint = function
- | { pat_desc = Tpat_constant (Const_nativeint _) } -> true
- | _ -> false
-
-and group_constructor = function
- | { pat_desc = Tpat_construct (_, _, _) } -> true
- | _ -> false
-
-and group_same_constructor tag = function
- | { pat_desc = Tpat_construct (_, cstr, _) } ->
- Types.equal_tag tag cstr.cstr_tag
- | _ -> false
-
-and group_variant = function
- | { pat_desc = Tpat_variant (_, _, _) } -> true
- | _ -> false
-
-and group_var = function
- | { pat_desc = Tpat_any } -> true
- | _ -> false
-
-and group_tuple = function
- | { pat_desc = Tpat_tuple _ | Tpat_any } -> true
- | _ -> false
-
-and group_record = function
- | { pat_desc = Tpat_record _ | Tpat_any } -> true
- | _ -> false
-
-and group_array = function
- | { pat_desc = Tpat_array _ } -> true
- | _ -> false
-
-and group_lazy = function
- | { pat_desc = Tpat_lazy _ } -> true
- | _ -> false
-
-let can_group p =
- match p.pat_desc with
- | Tpat_any -> group_var
- | Tpat_constant (Const_int _) -> group_const_int
- | Tpat_constant (Const_char _) -> group_const_char
- | Tpat_constant (Const_string _) -> group_const_string
- | Tpat_constant (Const_float _) -> group_const_float
- | Tpat_constant (Const_int32 _) -> group_const_int32
- | Tpat_constant (Const_int64 _) -> group_const_int64
- | Tpat_constant (Const_nativeint _) -> group_const_nativeint
- | Tpat_construct (_, { cstr_tag = Cstr_extension _ as t }, _) ->
+let can_group discr pat =
+ match (Pattern_head.desc discr, Pattern_head.desc (Simple.head pat)) with
+ | Any, Any
+ | Constant (Const_int _), Constant (Const_int _)
+ | Constant (Const_char _), Constant (Const_char _)
+ | Constant (Const_string _), Constant (Const_string _)
+ | Constant (Const_float _), Constant (Const_float _)
+ | Constant (Const_int32 _), Constant (Const_int32 _)
+ | Constant (Const_int64 _), Constant (Const_int64 _)
+ | Constant (Const_nativeint _), Constant (Const_nativeint _) ->
+ true
+ | Construct { cstr_tag = Cstr_extension _ as discr_tag }, Construct pat_cstr
+ ->
(* Extension constructors with distinct names may be equal thanks to
constructor rebinding. So we need to produce a specialized
submatrix for each syntactically-distinct constructor (with a threading
of exits such that each submatrix falls back to the
potentially-compatible submatrices below it). *)
- group_same_constructor t
- | Tpat_construct _ -> group_constructor
- | Tpat_tuple _ -> group_tuple
- | Tpat_record _ -> group_record
- | Tpat_array _ -> group_array
- | Tpat_variant (_, _, _) -> group_variant
- | Tpat_lazy _ -> group_lazy
- | _ -> fatal_error "Matching.can_group"
+ Types.equal_tag discr_tag pat_cstr.cstr_tag
+ | Construct _, Construct _
+ | Tuple _, (Tuple _ | Any)
+ | Record _, (Record _ | Any)
+ | Array _, Array _
+ | Variant _, Variant _
+ | Lazy, Lazy ->
+ true
+ | ( _,
+ ( Any
+ | Constant
+ ( Const_int _ | Const_char _ | Const_string _ | Const_float _
+ | Const_int32 _ | Const_int64 _ | Const_nativeint _ )
+ | Construct _ | Tuple _ | Record _ | Array _ | Variant _ | Lazy ) ) ->
+ false
let is_or p =
match p.pat_desc with
| Tpat_or (p1, p2, _) -> omega_like p1 || omega_like p2
| _ -> false
+let simple_omega_like p =
+ match Pattern_head.desc (Simple.head p) with
+ | Any -> true
+ | _ -> false
+
let equiv_pat p q = le_pat p q && le_pat q p
let rec extract_equiv_head p l =
match l with
- | ((q :: _, _) as cl) :: rem ->
- if equiv_pat p q then
+ | (((q, _), _) as cl) :: rem ->
+ if equiv_pat p (General.erase q) then
let others, rem = extract_equiv_head p rem in
(cl :: others, rem)
else
let safe_below_or_matrix l (q, qs) =
List.for_all
- (function
- | ({ pat_desc = Tpat_or _ } as p) :: ps, act_p ->
- disjoint p q || safe_below (ps, act_p) qs
+ (fun ((p, ps), act_p) ->
+ let p = General.erase p in
+ match p.pat_desc with
+ | Tpat_or _ -> disjoint p q || safe_below (ps, act_p) qs
| _ -> true)
l
If neither are possible we add to the bottom of the No matrix.
*)
- let insert_or_append (p, ps, act) rev_ors rev_no =
+ let insert_or_append (head, ps, act) rev_ors rev_no =
let safe_to_insert rem (p, ps) seen =
let _, not_e = extract_equiv_head p rem in
(* check append condition for head of O *)
safe_below_or_matrix not_e (p, ps)
&& (* check insert condition for tail of O *)
- List.for_all
- (fun cl ->
- match cl with
- | q :: _, _ -> disjoint p q
- | _ -> assert false)
- seen
+ List.for_all (fun ((q, _), _) -> disjoint p (General.erase q)) seen
in
let rec attempt seen = function
(* invariant: the new clause is safe to append at the end of
[seen] (but maybe not [rem] yet) *)
- | [] -> ((p :: ps, act) :: rev_ors, rev_no)
- | ([], _act) :: _ -> assert false
- | ((q :: qs, act_q) as cl) :: rem ->
+ | [] -> (((head, ps), act) :: rev_ors, rev_no)
+ | (((q, qs), act_q) as cl) :: rem ->
+ let p = General.erase head in
+ let q = General.erase q in
if (not (is_or q)) || disjoint p q then
attempt (cl :: seen) rem
else if
then
(* attempt insertion, for equivalent orpats with no variables *)
if safe_to_insert rem (p, ps) seen then
- (List.rev_append seen ((p :: ps, act) :: cl :: rem), rev_no)
+ (List.rev_append seen (((head, ps), act) :: cl :: rem), rev_no)
else
(* fail to insert or append *)
- (rev_ors, (p :: ps, act) :: rev_no)
+ (rev_ors, ((head, ps), act) :: rev_no)
else if safe_below (qs, act_q) ps then
attempt (cl :: seen) rem
else
- (rev_ors, (p :: ps, act) :: rev_no)
+ (rev_ors, ((head, ps), act) :: rev_no)
in
attempt [] rev_ors
end
(* Reconstruct default information from half_compiled pm list *)
-let as_matrix cases = get_mins le_pats (List.map (fun (ps, _) -> ps) cases)
+let as_matrix cases =
+ get_mins le_pats (List.map (fun ((p, ps), _) -> General.erase p :: ps) cases)
(*
Split a matching along the first column.
Some precompilation of or-patterns and
variable pattern occurs. Mostly this means that bindings
are performed now, being replaced by let-bindings
- in actions (cf. half_simplify_cases).
+ in actions (cf. Half_simple.of_clause).
Additionally, if the match argument is a variable, matchings whose
first column is made of variables only are split further
Note: we assume that the first column of each pattern is coherent -- all
patterns match values of the same type. This comes from the fact that
- we make agressive splitting decisions, splitting pattern heads that
+ we make aggressive splitting decisions, splitting pattern heads that
may be different into different submatrices; in particular, in a given
submatrix the first column is formed of first arguments to the same
constructor.
in a leftmost column.
Parmatch has to be more conservative because it splits less
- agressively: submatrices will contain not just the arguments of
+ aggressively: submatrices will contain not just the arguments of
a given pattern head, but also other lines that may be compatible with
it, in particular those with a leftmost omega and those starting with
an extension constructor that may be equal to it.
*)
-let rec split_or argo cls args def =
- let cls = half_simplify_cases args cls in
- let rec do_split rev_before rev_ors rev_no = function
+let rec split_or argo (cls : Half_simple.clause list) args def =
+ let rec do_split (rev_before : Simple.clause list) rev_ors rev_no = function
| [] ->
cons_next (List.rev rev_before) (List.rev rev_ors) (List.rev rev_no)
- | ((p :: ps, act) as cl) :: rem ->
- if not (safe_before cl rev_no) then
- do_split rev_before rev_ors (cl :: rev_no) rem
- else if (not (is_or p)) && safe_before cl rev_ors then
- do_split (cl :: rev_before) rev_ors rev_no rem
- else
- let rev_ors, rev_no =
- Or_matrix.insert_or_append (p, ps, act) rev_ors rev_no
- in
- do_split rev_before rev_ors rev_no rem
- | _ -> assert false
+ | cl :: rem when not (safe_before cl rev_no) ->
+ do_split rev_before rev_ors (cl :: rev_no) rem
+ | (((p, ps), act) as cl) :: rem -> (
+ match p.pat_desc with
+ | #simple_view as view when safe_before cl rev_ors ->
+ do_split
+ ((({ p with pat_desc = view }, ps), act) :: rev_before)
+ rev_ors rev_no rem
+ | _ ->
+ let rev_ors, rev_no =
+ Or_matrix.insert_or_append (p, ps, act) rev_ors rev_no
+ in
+ do_split rev_before rev_ors rev_no rem
+ )
and cons_next yes yesor no =
let def, nexts =
match no with
(where it is not always possible to syntactically decide whether two
different heads match different values), but this is handled by the
[can_group] function. *)
- let rec split cls =
+ let rec split (cls : Simple.clause list) =
let discr = what_is_first_case cls in
collect discr [] [] cls
and collect group_discr rev_yes rev_no = function
- | ([], _) :: _ -> assert false
- | [ ((ps, _) as cl) ] when rev_yes <> [] && List.for_all omega_like ps ->
+ | [ (((p, ps), _) as cl) ]
+ when rev_yes <> [] && simple_omega_like p && List.for_all omega_like ps ->
(* This enables an extra division in some frequent cases:
last row is made of variables only
This optimisation is tested in the first part of
testsuite/tests/basic/patmatch_split_no_or.ml *)
collect group_discr rev_yes (cl :: rev_no) []
- | ((p :: _, _) as cl) :: rem ->
+ | (((p, _), _) as cl) :: rem ->
if can_group group_discr p && safe_before cl rev_no then
collect group_discr (cl :: rev_yes) rev_no rem
else if should_split group_discr then (
insert_split group_discr yes no def k
and insert_split group_discr yes no def k =
let precompile_group =
- if group_var group_discr then
- precompile_var
- else
- do_not_precompile
+ match Pattern_head.desc group_discr with
+ | Any -> precompile_var
+ | _ -> do_not_precompile
in
match no with
| [] -> precompile_group args yes def k
(Default_environment.cons matrix idef def)
((idef, next) :: nexts)
and should_split group_discr =
- match group_discr.pat_desc with
- | Tpat_construct (_, { cstr_tag = Cstr_extension _ }, _) ->
+ match Pattern_head.desc group_discr with
+ | Construct { cstr_tag = Cstr_extension _ } ->
(* it is unlikely that we will raise anything, so we split now *)
true
| _ -> false
do_not_precompile args cls def k
| _ -> (
(* Precompile *)
+ let var_args = arg :: rargs in
let var_cls =
List.map
- (fun (ps, act) ->
- match ps with
- | p :: ps ->
- assert (group_var p);
- (ps, act)
- | _ -> assert false)
+ (fun ((p, ps), act) ->
+ assert (simple_omega_like p);
+
+ (* we learned by pattern-matching on [args]
+ that [p::ps] has at least two arguments,
+ so [ps] must be non-empty *)
+ half_simplify_clause ~arg:(fst arg) (ps, act))
cls
and var_def = Default_environment.pop_column def in
let { me = first; matrix }, nexts =
- split_or (Some v) var_cls (arg :: rargs) var_def
+ split_or (Some v) var_cls var_args var_def
in
(* Compute top information *)
match nexts with
(fun (mat, e) -> add_omega_column mat, e)
top_default (* assuming it'd been bound. *)
]}
- As we would be loosing information: [def] is more precise
+ As we would be losing information: [def] is more precise
than [add_omega_column (pop_column def)]. *)
List.fold_right
(fun (e, pmh) ->
},
k )
-and precompile_or argo cls ors args def k =
+and precompile_or argo (cls : Simple.clause list) ors args def k =
let rec do_cases = function
- | (({ pat_desc = Tpat_or _ } as orp) :: patl, action) :: rem ->
- let others, rem = extract_equiv_head orp rem in
- let orpm =
- { cases =
- (patl, action)
- :: List.map
- (function
- | _ :: ps, action -> (ps, action)
- | _ -> assert false)
- others;
- args =
- ( match args with
- | _ :: r -> r
- | _ -> assert false
- );
- default = Default_environment.pop_compat orp def
- }
- in
- let pm_fv = pm_free_variables orpm in
- let vars =
- (* bound variables of the or-pattern and used in the orpm actions *)
- Typedtree.pat_bound_idents_full orp
- |> List.filter (fun (id, _, _) -> Ident.Set.mem id pm_fv)
- |> List.map (fun (id, _, ty) ->
- (id, Typeopt.value_kind orp.pat_env ty))
- in
- let or_num = next_raise_count () in
- let new_patl = Parmatch.omega_list patl in
- let mk_new_action vs =
- Lstaticraise (or_num, List.map (fun v -> Lvar v) vs)
- in
- let rem_cases, rem_handlers = do_cases rem in
- let cases =
- explode_or_pat orp argo new_patl mk_new_action (List.map fst vars) []
- rem_cases
- in
- let handler =
- { provenance = [ [ orp ] ]; exit = or_num; vars; pm = orpm }
- in
- (cases, handler :: rem_handlers)
- | cl :: rem ->
- let new_ord, new_to_catch = do_cases rem in
- (cl :: new_ord, new_to_catch)
| [] -> ([], [])
+ | ((p, patl), action) :: rem -> (
+ match p.pat_desc with
+ | #simple_view as view ->
+ let new_ord, new_to_catch = do_cases rem in
+ ( (({ p with pat_desc = view }, patl), action) :: new_ord,
+ new_to_catch )
+ | `Or _ ->
+ let orp = General.erase p in
+ let others, rem = extract_equiv_head orp rem in
+ let orpm =
+ { cases =
+ (patl, action)
+ :: List.map (fun ((_, ps), action) -> (ps, action)) others;
+ args =
+ ( match args with
+ | _ :: r -> r
+ | _ -> assert false
+ );
+ default = Default_environment.pop_compat orp def
+ }
+ in
+ let pm_fv = pm_free_variables orpm in
+ let vars =
+ (* bound variables of the or-pattern and used in the orpm
+ actions *)
+ Typedtree.pat_bound_idents_full orp
+ |> List.filter (fun (id, _, _) -> Ident.Set.mem id pm_fv)
+ |> List.map (fun (id, _, ty) ->
+ (id, Typeopt.value_kind orp.pat_env ty))
+ in
+ let or_num = next_raise_count () in
+ let new_patl = Parmatch.omega_list patl in
+ let mk_new_action ~vars =
+ Lstaticraise (or_num, List.map (fun v -> Lvar v) vars)
+ in
+ let rem_cases, rem_handlers = do_cases rem in
+ let cases =
+ Simple.explode_or_pat (p, new_patl) ~arg:argo
+ ~mk_action:mk_new_action ~vars:(List.map fst vars) rem_cases
+ in
+ let handler =
+ { provenance = [ [ orp ] ];
+ exit = or_num;
+ vars;
+ pm = orpm
+ }
+ in
+ (cases, handler :: rem_handlers)
+ )
in
let cases, handlers = do_cases ors in
- let matrix = as_matrix (cls @ ors)
+ let matrix =
+ as_matrix
+ ((cls : Simple.clause list :> General.clause list)
+ @ (ors : Half_simple.clause list :> General.clause list)
+ )
and body = { cases = cls @ cases; args; default = def } in
( { me = PmOr { body; handlers; or_matrix = matrix };
matrix;
},
k )
-let split_and_precompile argo pm =
- let { me = next }, nexts = split_or argo pm.cases pm.args pm.default in
+let dbg_split_and_precompile pm next nexts =
if
dbg
&& (nexts <> []
)
then (
Format.eprintf "** SPLIT **\n";
- pretty_pm pm;
+ pretty_pm (erase_pm pm);
pretty_precompiled_res next nexts
- );
+ )
+
+let split_and_precompile_simplified pm =
+ let { me = next }, nexts = split_no_or pm.cases pm.args pm.default [] in
+ dbg_split_and_precompile pm next nexts;
+ (next, nexts)
+
+let split_and_precompile_half_simplified ~arg pm =
+ let { me = next }, nexts = split_or arg pm.cases pm.args pm.default in
+ dbg_split_and_precompile pm next nexts;
(next, nexts)
+let split_and_precompile ~arg_id ~arg_lambda pm =
+ let pm =
+ { pm with cases = List.map (half_simplify_clause ~arg:arg_lambda) pm.cases }
+ in
+ split_and_precompile_half_simplified ~arg:arg_id pm
+
(* General divide functions *)
-type cell = { pm : pattern_matching; ctx : Context.t; discr : pattern }
+type cell = {
+ pm : initial_clause pattern_matching;
+ ctx : Context.t;
+ discr : pattern
+}
(** a submatrix after specializing by discriminant pattern;
[ctx] is the context shared by all rows. *)
in
{ division with cells }
-let divide make eq_key get_key get_args ctx (pm : pattern_matching) =
- let add clause division =
- match clause with
- | [], _ -> assert false
- | p :: patl, action ->
- add_in_div (make p pm.default ctx) eq_key (get_key p)
- (get_args p patl, action)
- division
+let divide make eq_key get_key get_args ctx
+ (pm : Simple.clause pattern_matching) =
+ let add ((p, patl), action) division =
+ let p = General.erase p in
+ add_in_div (make p pm.default ctx) eq_key (get_key p)
+ (get_args p patl, action)
+ division
in
List.fold_right add pm.cases { args = pm.args; cells = [] }
pm.cases <- patl_action :: pm.cases;
pm
-let divide_line make_ctx make get_args discr ctx (pm : pattern_matching) =
- let add clause submatrix =
- match clause with
- | [], _ -> assert false
- | p :: patl, action -> add_line (get_args p patl, action) submatrix
+let divide_line make_ctx make get_args discr ctx
+ (pm : Simple.clause pattern_matching) =
+ let add ((p, patl), action) submatrix =
+ let p = General.erase p in
+ add_line (get_args p patl, action) submatrix
in
let pm = List.fold_right add pm.cases (make pm.default pm.args) in
{ pm; ctx = make_ctx ctx; discr }
match q.pat_desc with
| Tpat_or (_, _, _) ->
(* we cannot preserve the or-pattern as in the arity-1 case,
- because we cannot express
- (K (p1, .., pn) | K (q1, .. qn))
- as (p1 .. pn | q1 .. qn) *)
+ because we cannot express
+ (K (p1, .., pn) | K (q1, .. qn))
+ as (p1 .. pn | q1 .. qn) *)
raise OrPat
| Tpat_construct (_, cstr', args)
when Types.may_equal_constr cstr cstr' ->
| _ -> raise NoMatch
)
-let make_constr_matching p def ctx = function
+let make_constr_matching ~scopes p def ctx = function
| [] -> fatal_error "Matching.make_constr_matching"
| (arg, _mut) :: argl ->
let cstr = pat_as_constr p in
match cstr.cstr_tag with
| Cstr_constant _
| Cstr_block _ ->
- make_field_args p.pat_loc Alias arg 0 (cstr.cstr_arity - 1) argl
+ make_field_args (of_location ~scopes p.pat_loc)
+ Alias arg 0 (cstr.cstr_arity - 1) argl
| Cstr_unboxed -> (arg, Alias) :: argl
| Cstr_extension _ ->
- make_field_args p.pat_loc Alias arg 1 cstr.cstr_arity argl
+ make_field_args (of_location ~scopes p.pat_loc)
+ Alias arg 1 cstr.cstr_arity argl
in
{ pm =
{ cases = [];
discr = normalize_pat p
}
-let divide_constructor ctx pm =
- divide make_constr_matching ( = ) get_key_constr get_args_constr ctx pm
+let divide_constructor ~scopes ctx pm =
+ divide (make_constr_matching ~scopes) ( = )
+ get_key_constr get_args_constr ctx pm
(* Matching against a variant *)
| Tpat_any -> omega :: rem
| _ -> raise NoMatch
-let make_variant_matching_nonconst p lab def ctx = function
+let make_variant_matching_nonconst ~scopes p lab def ctx = function
| [] -> fatal_error "Matching.make_variant_matching_nonconst"
| (arg, _mut) :: argl ->
let def =
Default_environment.specialize (matcher_variant_nonconst lab) def
- and ctx = Context.specialize p ctx in
+ and ctx = Context.specialize p ctx
+ and loc = of_location ~scopes p.pat_loc in
{ pm =
{ cases = [];
- args = (Lprim (Pfield 1, [ arg ], p.pat_loc), Alias) :: argl;
+ args = (Lprim (Pfield 1, [ arg ], loc), Alias)
+ :: argl;
default = def
};
ctx;
discr = normalize_pat p
}
-let divide_variant row ctx { cases = cl; args; default = def } =
+let divide_variant ~scopes row ctx { cases = cl; args; default = def } =
let row = Btype.row_repr row in
let rec divide = function
- | (({ pat_desc = Tpat_variant (lab, pato, _) } as p) :: patl, action)
- :: rem -> (
+ | [] -> { args; cells = [] }
+ | ((p, patl), action) :: rem
+ -> (
+ let lab, pato = match p.pat_desc with
+ | `Variant (lab, pato, _) -> lab, pato
+ | _ -> assert false
+ in
+ let p = General.erase p in
let variants = divide rem in
if
try Btype.row_field_repr (List.assoc lab row.row_fields) = Rabsent
( = ) (Cstr_constant tag) (patl, action) variants
| Some pat ->
add_in_div
- (make_variant_matching_nonconst p lab def ctx)
+ (make_variant_matching_nonconst ~scopes p lab def ctx)
( = ) (Cstr_block tag)
(pat :: patl, action)
variants
)
- | _ -> { args; cells = [] }
in
divide cl
Env.add_persistent_structure mod_ident Env.initial_safe_string
in
match Env.open_pers_signature modname env with
- | exception Not_found ->
+ | Error `Not_found ->
fatal_error ("Module " ^ modname ^ " unavailable.")
- | env -> (
+ | Ok env -> (
match Env.find_value_by_name (Longident.Lident field) env with
| exception Not_found ->
fatal_error ("Primitive " ^ modname ^ "." ^ field ^ " not found.")
- | path, _ -> transl_value_path Location.none env path
+ | path, _ -> transl_value_path Loc_unknown env path
))
let code_force_lazy_block = get_mod_field "CamlinternalLazy" "force_lazy_block"
tag,
Lprim (Pccall prim_obj_tag, [ varg ], loc),
Lifthenelse
- ( (* if (tag == Obj.forward_tag) then varg.(0) else ... *)
- Lprim
+ (* if (tag == Obj.forward_tag) then varg.(0) else ... *)
+ ( Lprim
( Pintcomp Ceq,
[ tag_var; Lconst (Const_base (Const_int Obj.forward_tag)) ],
loc ),
Lprim (Pfield 0, [ varg ], loc),
Lifthenelse
- ( (* if (tag == Obj.lazy_tag) then Lazy.force varg else ... *)
- Lprim
+ (* if (tag == Obj.lazy_tag) then Lazy.force varg else ... *)
+ ( Lprim
( Pintcomp Ceq,
[ tag_var; Lconst (Const_base (Const_int Obj.lazy_tag)) ],
loc ),
| [] -> fatal_error "Matching.make_lazy_matching"
| (arg, _mut) :: argl ->
{ cases = [];
- args = (inline_lazy_force arg Location.none, Strict) :: argl;
+ args = (inline_lazy_force arg Loc_unknown, Strict) :: argl;
default = Default_environment.specialize matcher_lazy def
}
default = Default_environment.specialize (matcher_tuple arity) def
}
-let divide_tuple arity p ctx pm =
+let divide_tuple ~scopes arity p ctx pm =
divide_line (Context.specialize p)
- (make_tuple_matching p.pat_loc arity)
+ (make_tuple_matching (of_location ~scopes p.pat_loc) arity)
(get_args_tuple arity) p ctx pm
(* Matching against a record pattern *)
let def = Default_environment.specialize (matcher_record nfields) def in
{ cases = []; args = make_args 0; default = def }
-let divide_record all_labels p ctx pm =
+let divide_record ~scopes all_labels p ctx pm =
let get_args = get_args_record (Array.length all_labels) in
divide_line (Context.specialize p)
- (make_record_matching p.pat_loc all_labels)
+ (make_record_matching (of_location ~scopes p.pat_loc) all_labels)
get_args p ctx pm
(* Matching against an array pattern *)
| Tpat_any -> Parmatch.omegas len @ rem
| _ -> raise NoMatch
-let make_array_matching kind p def ctx = function
+let make_array_matching ~scopes kind p def ctx = function
| [] -> fatal_error "Matching.make_array_matching"
| (arg, _mut) :: argl ->
let len = get_key_array p in
( Lprim
( Parrayrefu kind,
[ arg; Lconst (Const_base (Const_int pos)) ],
- p.pat_loc ),
+ (of_location ~scopes p.pat_loc) ),
StrictOpt )
:: make_args (pos + 1)
in
discr = normalize_pat p
}
-let divide_array kind ctx pm =
- divide (make_array_matching kind) ( = ) get_key_array get_args_array ctx pm
+let divide_array ~scopes kind ctx pm =
+ divide (make_array_matching ~scopes kind) ( = )
+ get_key_array get_args_array ctx pm
(*
Specific string test sequence
type act = Lambda.lambda
- let make_prim p args = Lprim (p, args, Location.none)
+ type loc = Lambda.scoped_location
+
+ let make_prim p args = Lprim (p, args, Loc_unknown)
let make_offset arg n =
match n with
| 0 -> arg
- | _ -> Lprim (Poffsetint n, [ arg ], Location.none)
+ | _ -> Lprim (Poffsetint n, [ arg ], Loc_unknown)
let bind arg body =
let newvar, newarg =
let make_const i = Lconst (Const_base (Const_int i))
- let make_isout h arg = Lprim (Pisout, [ h; arg ], Location.none)
+ let make_isout h arg = Lprim (Pisout, [ h; arg ], Loc_unknown)
- let make_isin h arg = Lprim (Pnot, [ make_isout h arg ], Location.none)
+ let make_isin h arg = Lprim (Pnot, [ make_isout h arg ], Loc_unknown)
let make_if cond ifso ifnot = Lifthenelse (cond, ifso, ifnot)
| (i, act) :: rem ->
let act_index =
(* In case there is some hole and that a switch is emitted,
- action 0 will be used as the action of unreachable
- cases (cf. switch.ml, make_switch).
- Hence, this action will be shared *)
+ action 0 will be used as the action of unreachable
+ cases (cf. switch.ml, make_switch).
+ Hence, this action will be shared *)
if some_hole rem then
store.act_store_shared () act
else
(Some (Lstaticraise (idef, [])), Jumps.singleton idef ctx)
| None ->
(* Act as Total, this means
- If no appropriate default matrix exists,
- then this switch cannot fail *)
+ If no appropriate default matrix exists,
+ then this switch cannot fail *)
(None, Jumps.empty)
)
| Total -> (None, Jumps.empty)
List.map
(fun (c, act) ->
match c with
- | Const_string (s, _) -> (s, act)
+ | Const_string (s, _, _) -> (s, act)
| _ -> assert false)
const_lambda_list
in
in
split_rec tag_lambda_list
-let combine_constructor loc arg ex_pat cstr partial ctx def
+let combine_constructor loc arg pat_env cstr partial ctx def
(tag_lambda_list, total1, pats) =
match cstr.cstr_tag with
| Cstr_extension _ ->
let tests =
List.fold_right
(fun (path, act) rem ->
- let ext = transl_extension_path loc ex_pat.pat_env path in
+ let ext = transl_extension_path loc pat_env path in
Lifthenelse
(Lprim (Pintcomp Ceq, [ Lvar tag; ext ], loc), act, rem))
nonconsts default
in
List.fold_right
(fun (path, act) rem ->
- let ext = transl_extension_path loc ex_pat.pat_env path in
+ let ext = transl_extension_path loc pat_env path in
Lifthenelse (Lprim (Pintcomp Ceq, [ arg; ext ], loc), act, rem))
consts nonconst_lambda
in
(* To find reasonable names for variables *)
let rec name_pattern default = function
- | (pat :: _, _) :: rem -> (
+ | ((pat, _), _) :: rem -> (
match pat.pat_desc with
| Tpat_var (id, _) -> id
| Tpat_alias (_, id, _) -> id
Output: a lambda term, a jump summary {..., exit number -> context, .. }
*)
-let rec compile_match repr partial ctx (m : pattern_matching) =
- match m with
- | { cases = []; args = [] } -> comp_exit ctx m
- | { cases = ([], action) :: rem } ->
+let rec compile_match ~scopes repr partial ctx
+ (m : initial_clause pattern_matching) =
+ match m.cases with
+ | ([], action) :: rem ->
if is_guarded action then
let lambda, total =
- compile_match None partial ctx { m with cases = rem }
+ compile_match ~scopes None partial ctx { m with cases = rem }
in
(event_branch repr (patch_guarded lambda action), total)
else
(event_branch repr action, Jumps.empty)
+ | nonempty_cases ->
+ compile_match_nonempty ~scopes repr partial ctx
+ { m with cases = List.map Non_empty_clause.of_initial nonempty_cases }
+
+and compile_match_nonempty ~scopes repr partial ctx
+ (m : Typedtree.pattern Non_empty_clause.t pattern_matching) =
+ match m with
+ | { cases = []; args = [] } -> comp_exit ctx m
| { args = (arg, str) :: argl } ->
let v, newarg = arg_to_var arg m.cases in
+ let args = (newarg, Alias) :: argl in
+ let cases = List.map (half_simplify_nonempty ~arg:newarg) m.cases in
+ let m = { m with args; cases } in
let first_match, rem =
- split_and_precompile (Some v) { m with args = (newarg, Alias) :: argl }
- in
- let lam, total =
- comp_match_handlers
- (( if dbg then
- do_compile_matching_pr
- else
- do_compile_matching
- )
- repr)
- partial ctx first_match rem
- in
- (bind_check str v arg lam, total)
+ split_and_precompile_half_simplified ~arg:(Some v) m in
+ combine_handlers ~scopes repr partial ctx (v, str, arg) first_match rem
| _ -> assert false
+and compile_match_simplified ~scopes repr partial ctx
+ (m : Simple.clause pattern_matching) =
+ match m with
+ | { cases = []; args = [] } -> comp_exit ctx m
+ | { args = ((Lvar v as arg), str) :: argl } ->
+ let args = (arg, Alias) :: argl in
+ let m = { m with args } in
+ let first_match, rem = split_and_precompile_simplified m in
+ combine_handlers ~scopes repr partial ctx (v, str, arg) first_match rem
+ | _ -> assert false
+
+and combine_handlers ~scopes repr partial ctx (v, str, arg) first_match rem =
+ let lam, total =
+ comp_match_handlers
+ (( if dbg then
+ do_compile_matching_pr ~scopes
+ else
+ do_compile_matching ~scopes
+ )
+ repr)
+ partial ctx first_match rem
+ in
+ (bind_check str v arg lam, total)
+
(* verbose version of do_compile_matching, for debug *)
-and do_compile_matching_pr repr partial ctx x =
+and do_compile_matching_pr ~scopes repr partial ctx x =
Format.eprintf "COMPILE: %s\nMATCH\n"
( match partial with
| Partial -> "Partial"
pretty_precompiled x;
Format.eprintf "CTX\n";
Context.eprintf ctx;
- let ((_, jumps) as r) = do_compile_matching repr partial ctx x in
+ let ((_, jumps) as r) = do_compile_matching ~scopes repr partial ctx x in
Format.eprintf "JUMPS\n";
Jumps.eprintf jumps;
r
-and do_compile_matching repr partial ctx pmh =
+and do_compile_matching ~scopes repr partial ctx pmh =
match pmh with
| Pm pm -> (
let arg =
*)
assert false
in
- let pat = what_is_cases pm.cases in
- match pat.pat_desc with
- | Tpat_any ->
- compile_no_test divide_var Context.rshift repr partial ctx pm
- | Tpat_tuple patl ->
- compile_no_test
- (divide_tuple (List.length patl) (normalize_pat pat))
+ let ph = what_is_cases pm.cases in
+ let pomega = Pattern_head.to_omega_pattern ph in
+ let ploc = Pattern_head.loc ph in
+ match Pattern_head.desc ph with
+ | Any ->
+ compile_no_test ~scopes divide_var Context.rshift repr partial ctx pm
+ | Tuple l ->
+ compile_no_test ~scopes (divide_tuple ~scopes l pomega)
Context.combine repr partial ctx pm
- | Tpat_record ((_, lbl, _) :: _, _) ->
- compile_no_test
- (divide_record lbl.lbl_all (normalize_pat pat))
+ | Record [] -> assert false
+ | Record (lbl :: _) ->
+ compile_no_test ~scopes
+ (divide_record ~scopes lbl.lbl_all pomega)
Context.combine repr partial ctx pm
- | Tpat_constant cst ->
+ | Constant cst ->
compile_test
- (compile_match repr partial)
+ (compile_match ~scopes repr partial)
partial divide_constant
- (combine_constant pat.pat_loc arg cst partial)
+ (combine_constant (of_location ~scopes ploc) arg cst partial)
ctx pm
- | Tpat_construct (_, cstr, _) ->
+ | Construct cstr ->
compile_test
- (compile_match repr partial)
- partial divide_constructor
- (combine_constructor pat.pat_loc arg pat cstr partial)
+ (compile_match ~scopes repr partial)
+ partial (divide_constructor ~scopes)
+ (combine_constructor (of_location ~scopes ploc) arg
+ (Pattern_head.env ph) cstr partial)
ctx pm
- | Tpat_array _ ->
- let kind = Typeopt.array_pattern_kind pat in
+ | Array _ ->
+ let kind = Typeopt.array_pattern_kind pomega in
compile_test
- (compile_match repr partial)
- partial (divide_array kind)
- (combine_array pat.pat_loc arg kind partial)
+ (compile_match ~scopes repr partial)
+ partial (divide_array ~scopes kind)
+ (combine_array (of_location ~scopes ploc) arg kind partial)
ctx pm
- | Tpat_lazy _ ->
- compile_no_test
- (divide_lazy (normalize_pat pat))
+ | Lazy ->
+ compile_no_test ~scopes
+ (divide_lazy pomega)
Context.combine repr partial ctx pm
- | Tpat_variant (_, _, row) ->
+ | Variant { cstr_row = row } ->
compile_test
- (compile_match repr partial)
- partial (divide_variant !row)
- (combine_variant pat.pat_loc !row arg partial)
+ (compile_match ~scopes repr partial)
+ partial (divide_variant ~scopes !row)
+ (combine_variant (of_location ~scopes ploc) !row arg partial)
ctx pm
- | _ -> assert false
)
| PmVar { inside = pmh } ->
let lam, total =
- do_compile_matching repr partial (Context.lshift ctx) pmh
+ do_compile_matching ~scopes repr partial (Context.lshift ctx) pmh
in
(lam, Jumps.map Context.rshift total)
| PmOr { body; handlers } ->
- let lam, total = compile_match repr partial ctx body in
- compile_orhandlers (compile_match repr partial) lam total ctx handlers
+ let lam, total =
+ compile_match_simplified ~scopes repr partial ctx body in
+ compile_orhandlers (compile_match ~scopes repr partial)
+ lam total ctx handlers
-and compile_no_test divide up_ctx repr partial ctx to_match =
+and compile_no_test ~scopes divide up_ctx repr partial ctx to_match =
let { pm = this_match; ctx = this_ctx } = divide ctx to_match in
- let lambda, total = compile_match repr partial this_ctx this_match in
+ let lambda, total =
+ compile_match ~scopes repr partial this_ctx this_match in
(lambda, Jumps.map up_ctx total)
(* The entry points *)
I have generalized the patch, so as to also find mutable fields.
*)
-let is_lazy_pat p = match p.pat_desc with
+let is_lazy_pat p =
+ match p.pat_desc with
| Tpat_lazy _ -> true
| Tpat_alias _
| Tpat_variant _
| Tpat_var _
| Tpat_any ->
false
- | Tpat_exception _ -> assert false
-let has_lazy p =
- Typedtree.exists_pattern is_lazy_pat p
+let has_lazy p = Typedtree.exists_pattern is_lazy_pat p
let is_record_with_mutable_field p =
match p.pat_desc with
| Tpat_var _
| Tpat_any ->
false
- | Tpat_exception _ -> assert false
-let has_mutable p =
- Typedtree.exists_pattern is_record_with_mutable_field p
+let has_mutable p = Typedtree.exists_pattern is_record_with_mutable_field p
(* Downgrade Total when
1. Matching accesses some mutable fields;
else
Total
-let check_partial_list =
- check_partial (List.exists has_mutable) (List.exists has_lazy)
+let check_partial_list pats_act_list =
+ check_partial (List.exists has_mutable) (List.exists has_lazy) pats_act_list
-let check_partial = check_partial has_mutable has_lazy
+let check_partial pat_act_list =
+ check_partial has_mutable has_lazy pat_act_list
(* have toplevel handler when appropriate *)
else
Lstaticcatch (lambda, (i, []), handler_fun ())
-let compile_matching repr handler_fun arg pat_act_list partial =
+let compile_matching ~scopes repr handler_fun arg pat_act_list partial =
let partial = check_partial pat_act_list partial in
match partial with
| Partial -> (
}
in
try
- let lambda, total = compile_match repr partial (Context.start 1) pm in
+ let lambda, total =
+ compile_match ~scopes repr partial (Context.start 1) pm in
check_total total lambda raise_num handler_fun
with Unused -> assert false
(* ; handler_fun() *)
default = Default_environment.empty
}
in
- let lambda, total = compile_match repr partial (Context.start 1) pm in
+ let lambda, total =
+ compile_match ~scopes repr partial (Context.start 1) pm in
assert (Jumps.is_empty total);
lambda
-let partial_function loc () =
+let partial_function ~scopes loc () =
+ let sloc = of_location ~scopes loc in
let slot =
- transl_extension_path loc Env.initial_safe_string Predef.path_match_failure
+ transl_extension_path sloc Env.initial_safe_string Predef.path_match_failure
in
- let fname, line, char = Location.get_pos_info loc.Location.loc_start in
+ let fname, line, char =
+ Location.get_pos_info loc.Location.loc_start in
Lprim
( Praise Raise_regular,
[ Lprim
Lconst
(Const_block
( 0,
- [ Const_base (Const_string (fname, None));
+ [ Const_base (Const_string (fname, loc, None));
Const_base (Const_int line);
Const_base (Const_int char)
] ))
],
- loc )
+ sloc )
],
- loc )
+ sloc )
-let for_function loc repr param pat_act_list partial =
- compile_matching repr (partial_function loc) param pat_act_list partial
+let for_function ~scopes loc repr param pat_act_list partial =
+ let f () = partial_function ~scopes loc () in
+ compile_matching ~scopes repr f param pat_act_list partial
(* In the following two cases, exhaustiveness info is not available! *)
-let for_trywith param pat_act_list =
- compile_matching None
- (fun () -> Lprim (Praise Raise_reraise, [ param ], Location.none))
+let for_trywith ~scopes param pat_act_list =
+ compile_matching ~scopes None
+ (fun () -> Lprim (Praise Raise_reraise, [ param ], Loc_unknown))
param pat_act_list Partial
-let simple_for_let loc param pat body =
- compile_matching None (partial_function loc) param [ (pat, body) ] Partial
+let simple_for_let ~scopes loc param pat body =
+ compile_matching ~scopes None (partial_function ~scopes loc)
+ param [ (pat, body) ] Partial
(* Optimize binding of immediate tuples
| Ltrywith (l1, id, l2) -> Ltrywith (map_return f l1, id, map_return f l2)
| Lstaticcatch (l1, b, l2) ->
Lstaticcatch (map_return f l1, b, map_return f l2)
+ | Lswitch (s, sw, loc) ->
+ let map_cases cases =
+ List.map (fun (i, l) -> (i, map_return f l)) cases
+ in
+ Lswitch
+ ( s,
+ { sw with
+ sw_consts = map_cases sw.sw_consts;
+ sw_blocks = map_cases sw.sw_blocks;
+ sw_failaction = Option.map (map_return f) sw.sw_failaction
+ },
+ loc )
+ | Lstringswitch (s, cases, def, loc) ->
+ Lstringswitch
+ ( s,
+ List.map (fun (s, l) -> (s, map_return f l)) cases,
+ Option.map (map_return f) def,
+ loc )
| (Lstaticraise _ | Lprim (Praise _, _, _)) as l -> l
- | l -> f l
+ | ( Lvar _ | Lconst _ | Lapply _ | Lfunction _ | Lsend _ | Lprim _ | Lwhile _
+ | Lfor _ | Lassign _ | Lifused _ ) as l ->
+ f l
(* The 'opt' reference indicates if the optimization is worthy.
can be costly (one unnecessary tuple allocation).
*)
-let assign_pat opt nraise catch_ids loc pat lam =
+let assign_pat ~scopes opt nraise catch_ids loc pat lam =
let rec collect acc pat lam =
match (pat.pat_desc, lam) with
| Tpat_tuple patl, Lprim (Pmakeblock _, lams, _) ->
List.fold_left2 collect_const acc patl scl
| _ ->
(* pattern idents will be bound in staticcatch (let body), so we
- refresh them here to guarantee binders uniqueness *)
+ refresh them here to guarantee binders uniqueness *)
let pat_ids = pat_bound_idents pat in
let fresh_ids = List.map (fun id -> (id, Ident.rename id)) pat_ids in
(fresh_ids, alpha_pat fresh_ids pat, lam) :: acc
let fresh_var id = Lvar (Ident.find_same id tbl) in
Lstaticraise (nraise, List.map fresh_var catch_ids)
in
- let push_sublet code (_ids, pat, lam) = simple_for_let loc lam pat code in
+ let push_sublet code (_ids, pat, lam) =
+ simple_for_let ~scopes loc lam pat code in
List.fold_left push_sublet exit rev_sublets
-let for_let loc param pat body =
+let for_let ~scopes loc param pat body =
match pat.pat_desc with
| Tpat_any ->
(* This eliminates a useless variable (and stack slot in bytecode)
catch_ids
in
let ids = List.map (fun (id, _, _) -> id) catch_ids in
- let bind = map_return (assign_pat opt nraise ids loc pat) param in
+ let bind =
+ map_return (assign_pat ~scopes opt nraise ids loc pat) param in
if !opt then
Lstaticcatch (bind, (nraise, ids_with_kinds), body)
else
- simple_for_let loc param pat body
+ simple_for_let ~scopes loc param pat body
(* Handling of tupled functions and matchings *)
(* Easy case since variables are available *)
-let for_tupled_function loc paraml pats_act_list partial =
+let for_tupled_function ~scopes loc paraml pats_act_list partial =
let partial = check_partial_list pats_act_list partial in
let raise_num = next_raise_count () in
let omegas = [ List.map (fun _ -> omega) paraml ] in
in
try
let lambda, total =
- compile_match None partial (Context.start (List.length paraml)) pm
+ compile_match ~scopes None partial
+ (Context.start (List.length paraml)) pm
in
- check_total total lambda raise_num (partial_function loc)
- with Unused -> partial_function loc ()
+ check_total total lambda raise_num (partial_function ~scopes loc)
+ with Unused -> partial_function ~scopes loc ()
let flatten_pattern size p =
match p.pat_desc with
let flatten_cases size cases =
List.map
- (fun (ps, action) ->
- match ps with
- | [ p ] -> (flatten_pattern size p, action)
- | _ -> fatal_error "Matching.flatten_case")
+ (function
+ | (p, []), action -> (
+ match flatten_pattern size (General.erase p) with
+ | p :: ps -> ((p, ps), action)
+ | [] -> assert false
+ )
+ | _ -> fatal_error "Matching.flatten_hc_cases")
cases
let flatten_pm size args pm =
let flatten_handler size handler =
{ handler with provenance = flatten_matrix size handler.provenance }
+type pm_flattened =
+ | FPmOr of pattern pm_or_compiled
+ | FPm of pattern Non_empty_clause.t pattern_matching
+
let flatten_precompiled size args pmh =
match pmh with
- | Pm pm -> Pm (flatten_pm size args pm)
+ | Pm pm -> FPm (flatten_pm size args pm)
| PmOr { body = b; handlers = hs; or_matrix = m } ->
- PmOr
+ FPmOr
{ body = flatten_pm size args b;
handlers = List.map (flatten_handler size) hs;
or_matrix = flatten_matrix size m
Hence it needs a fourth argument, which it ignores
*)
-let compile_flattened repr partial ctx pmh =
+let compile_flattened ~scopes repr partial ctx pmh =
match pmh with
- | Pm pm -> compile_match repr partial ctx pm
- | PmOr { body = b; handlers = hs } ->
- let lam, total = compile_match repr partial ctx b in
- compile_orhandlers (compile_match repr partial) lam total ctx hs
- | PmVar _ -> assert false
+ | FPm pm -> compile_match_nonempty ~scopes repr partial ctx pm
+ | FPmOr { body = b; handlers = hs } ->
+ let lam, total = compile_match_nonempty ~scopes repr partial ctx b in
+ compile_orhandlers (compile_match ~scopes repr partial) lam total ctx hs
-let do_for_multiple_match loc paraml pat_act_list partial =
+let do_for_multiple_match ~scopes loc paraml pat_act_list partial =
let repr = None in
let partial = check_partial pat_act_list partial in
- let raise_num, pm1 =
+ let raise_num, arg, pm1 =
let raise_num, default =
match partial with
| Partial ->
(raise_num, Default_environment.(cons [ [ omega ] ] raise_num empty))
| Total -> (-1, Default_environment.empty)
in
+ let loc = of_location ~scopes loc in
+ let arg = Lprim (Pmakeblock (0, Immutable, None), paraml, loc) in
( raise_num,
+ arg,
{ cases = List.map (fun (pat, act) -> ([ pat ], act)) pat_act_list;
- args =
- [ (Lprim (Pmakeblock (0, Immutable, None), paraml, loc), Strict) ];
+ args = [ (arg, Strict) ];
default
} )
in
try
try
(* Once for checking that compilation is possible *)
- let next, nexts = split_and_precompile None pm1 in
+ let next, nexts =
+ split_and_precompile ~arg_id:None ~arg_lambda:arg pm1
+ in
let size = List.length paraml
and idl = List.map (fun _ -> Ident.create_local "*match*") paraml in
let args = List.map (fun id -> (Lvar id, Alias)) idl in
List.map (fun (e, pm) -> (e, flatten_precompiled size args pm)) nexts
in
let lam, total =
- comp_match_handlers (compile_flattened repr) partial
+ comp_match_handlers (compile_flattened ~scopes repr) partial
(Context.start size) flat_next flat_nexts
in
List.fold_right2 (bind Strict) idl paraml
( match partial with
- | Partial -> check_total total lam raise_num (partial_function loc)
+ | Partial ->
+ check_total total lam raise_num (partial_function ~scopes loc)
| Total ->
assert (Jumps.is_empty total);
lam
)
with Cannot_flatten -> (
- let lambda, total = compile_match None partial (Context.start 1) pm1 in
+ let lambda, total =
+ compile_match ~scopes None partial (Context.start 1) pm1 in
match partial with
- | Partial -> check_total total lambda raise_num (partial_function loc)
+ | Partial ->
+ check_total total lambda raise_num (partial_function ~scopes loc)
| Total ->
assert (Jumps.is_empty total);
lambda
| None -> k
| Some e -> Lambda.bind Strict v e k
-let for_multiple_match loc paraml pat_act_list partial =
+let for_multiple_match ~scopes loc paraml pat_act_list partial =
let v_paraml = List.map param_to_var paraml in
let paraml = List.map (fun (v, _) -> Lvar v) v_paraml in
List.fold_right bind_opt v_paraml
- (do_for_multiple_match loc paraml pat_act_list partial)
+ (do_for_multiple_match ~scopes loc paraml pat_act_list partial)
open Typedtree
open Lambda
-
+open Debuginfo.Scoped_location
(* Entry points to match compiler *)
val for_function:
- Location.t -> int ref option -> lambda -> (pattern * lambda) list ->
- partial -> lambda
+ scopes:scopes -> Location.t ->
+ int ref option -> lambda -> (pattern * lambda) list -> partial ->
+ lambda
val for_trywith:
- lambda -> (pattern * lambda) list -> lambda
+ scopes:scopes ->
+ lambda -> (pattern * lambda) list ->
+ lambda
val for_let:
- Location.t -> lambda -> pattern -> lambda -> lambda
+ scopes:scopes -> Location.t ->
+ lambda -> pattern -> lambda ->
+ lambda
val for_multiple_match:
- Location.t -> lambda list -> (pattern * lambda) list -> partial ->
+ scopes:scopes -> Location.t ->
+ lambda list -> (pattern * lambda) list -> partial ->
lambda
val for_tupled_function:
- Location.t -> Ident.t list -> (pattern list * lambda) list ->
- partial -> lambda
+ scopes:scopes -> Location.t ->
+ Ident.t list -> (pattern list * lambda) list -> partial ->
+ lambda
exception Cannot_flatten
(* Expand stringswitch to string test tree *)
val expand_stringswitch:
- Location.t -> lambda -> (string * lambda) list -> lambda option -> lambda
+ scoped_location -> lambda -> (string * lambda) list ->
+ lambda option -> lambda
-val inline_lazy_force : lambda -> Location.t -> lambda
+val inline_lazy_force : lambda -> scoped_location -> lambda
let rec struct_const ppf = function
| Const_base(Const_int n) -> fprintf ppf "%i" n
| Const_base(Const_char c) -> fprintf ppf "%C" c
- | Const_base(Const_string (s, _)) -> fprintf ppf "%S" s
+ | Const_base(Const_string (s, _, _)) -> fprintf ppf "%S" s
| Const_immstring s -> fprintf ppf "#%S" s
| Const_base(Const_float f) -> fprintf ppf "%s" f
| Const_base(Const_int32 n) -> fprintf ppf "%lil" n
| Plsrint -> fprintf ppf "lsr"
| Pasrint -> fprintf ppf "asr"
| Pintcomp(cmp) -> integer_comparison ppf cmp
+ | Pcompare_ints -> fprintf ppf "compare_ints"
+ | Pcompare_floats -> fprintf ppf "compare_floats"
+ | Pcompare_bints bi -> fprintf ppf "compare_bints %s" (boxed_integer_name bi)
| Poffsetint n -> fprintf ppf "%i+" n
| Poffsetref n -> fprintf ppf "+:=%i"n
| Pintoffloat -> fprintf ppf "int_of_float"
| Plsrint -> "Plsrint"
| Pasrint -> "Pasrint"
| Pintcomp _ -> "Pintcomp"
+ | Pcompare_ints -> "Pcompare_ints"
+ | Pcompare_floats -> "Pcompare_floats"
+ | Pcompare_bints _ -> "Pcompare"
| Poffsetint _ -> "Poffsetint"
| Poffsetref _ -> "Poffsetref"
| Pintoffloat -> "Pintoffloat"
begin match inline with
| Default_inline -> ()
| Always_inline -> fprintf ppf "always_inline@ "
+ | Hint_inline -> fprintf ppf "hint_inline@ "
| Never_inline -> fprintf ppf "never_inline@ "
| Unroll i -> fprintf ppf "unroll(%i)@ " i
end;
| Default_inline -> ()
| Always_inline -> fprintf ppf " always_inline"
| Never_inline -> fprintf ppf " never_inline"
+ | Hint_inline -> fprintf ppf " hint_inline"
| Unroll i -> fprintf ppf " never_inline(%i)" i
let apply_specialised_attribute ppf = function
| Lev_module_definition ident ->
Format.asprintf "module-defn(%a)" Ident.print ident
in
- fprintf ppf "@[<2>(%s %s(%i)%s:%i-%i@ %a)@]" kind
- ev.lev_loc.Location.loc_start.Lexing.pos_fname
- ev.lev_loc.Location.loc_start.Lexing.pos_lnum
- (if ev.lev_loc.Location.loc_ghost then "<ghost>" else "")
- ev.lev_loc.Location.loc_start.Lexing.pos_cnum
- ev.lev_loc.Location.loc_end.Lexing.pos_cnum
- lam expr
+ (* -dno-locations also hides the placement of debug events;
+ this is good for the readability of the resulting output (usually
+ the end-user goal when using -dno-locations), as it strongly
+ reduces the nesting level of subterms. *)
+ if not !Clflags.locations then lam ppf expr
+ else begin match ev.lev_loc with
+ | Loc_unknown ->
+ fprintf ppf "@[<2>(%s <unknown location>@ %a)@]" kind lam expr
+ | Loc_known {scopes; loc} ->
+ fprintf ppf "@[<2>(%s %s %s(%i)%s:%i-%i@ %a)@]" kind
+ (Debuginfo.Scoped_location.string_of_scopes scopes)
+ loc.Location.loc_start.Lexing.pos_fname
+ loc.Location.loc_start.Lexing.pos_lnum
+ (if loc.Location.loc_ghost then "<ghost>" else "")
+ loc.Location.loc_start.Lexing.pos_cnum
+ loc.Location.loc_end.Lexing.pos_cnum
+ lam expr
+ end
| Lifused(id, expr) ->
fprintf ppf "@[<2>(ifused@ %a@ %a)@]" Ident.print id lam expr
open Asttypes
open Lambda
+open Debuginfo.Scoped_location
(* To transform let-bound references into variables *)
ref (fun _ -> true)
let rec emit_tail_infos is_tail lambda =
- let call_kind args =
- if is_tail
- && ((not !Clflags.native_code)
- || (!is_tail_native_heuristic (List.length args)))
- then Annot.Tail
- else Annot.Stack in
match lambda with
| Lvar _ -> ()
| Lconst _ -> ()
if ap.ap_should_be_tailcall
&& not is_tail
&& Warnings.is_active Warnings.Expect_tailcall
- then Location.prerr_warning ap.ap_loc Warnings.Expect_tailcall;
+ then Location.prerr_warning (to_location ap.ap_loc)
+ Warnings.Expect_tailcall;
emit_tail_infos false ap.ap_func;
- list_emit_tail_infos false ap.ap_args;
- if !Clflags.annotations then
- Stypes.record (Stypes.An_call (ap.ap_loc, call_kind ap.ap_args))
+ list_emit_tail_infos false ap.ap_args
| Lfunction {body = lam} ->
emit_tail_infos true lam
| Llet (_str, _k, _, lam, body) ->
emit_tail_infos false body
| Lassign (_, lam) ->
emit_tail_infos false lam
- | Lsend (_, meth, obj, args, loc) ->
+ | Lsend (_, meth, obj, args, _loc) ->
emit_tail_infos false meth;
emit_tail_infos false obj;
- list_emit_tail_infos false args;
- if !Clflags.annotations then
- Stypes.record (Stypes.An_call (loc, call_kind (obj :: args)));
+ list_emit_tail_infos false args
| Levent (lam, _) ->
emit_tail_infos is_tail lam
| Lifused (_, lam) ->
Lapply {
ap_func = Lvar inner_id;
ap_args = args;
- ap_loc = Location.none;
+ ap_loc = Loc_unknown;
ap_should_be_tailcall = false;
ap_inlined = Default_inline;
ap_specialised = Default_specialise;
let current_scope = ref lam in
let check_static lf =
if lf.attr.local = Always_local then
- Location.prerr_warning lf.loc
+ Location.prerr_warning (to_location lf.loc)
(Warnings.Inlining_impossible
"This function cannot be compiled into a static continuation")
in
| {local = Always_local; _}
| {local = Default_local; inline = (Never_inline | Default_inline); _}
-> true
- | {local = Default_local; inline = (Always_inline | Unroll _); _}
+ | {local = Default_local;
+ inline = (Always_inline | Unroll _ | Hint_inline); _}
| {local = Never_local; _}
-> false
in
-> return:Lambda.value_kind
-> body:lambda
-> attr:function_attribute
- -> loc:Location.t
+ -> loc:Lambda.scoped_location
-> (Ident.t * lambda) list
(* To be filled by asmcomp/selectgen.ml *)
val geint : primitive
val gtint : primitive
type act
+ type loc
val bind : act -> (act -> act) -> act
val make_const : int -> act
val make_isout : act -> act -> act
val make_isin : act -> act -> act
val make_if : act -> act -> act -> act
- val make_switch : Location.t -> act -> int array -> act array -> act
+ val make_switch : loc -> act -> int array -> act array -> act
val make_catch : act -> int * (act -> act)
val make_exit : int -> act
end
val gtint : primitive
(* type of actions *)
type act
+ (* type of source locations *)
+ type loc
(* Various constructors, for making a binder,
adding one integer, etc. *)
(* construct an actual switch :
make_switch arg cases acts
NB: cases is in the value form *)
- val make_switch :
- Location.t -> act -> int array -> act array -> act
+ val make_switch : loc -> act -> int array -> act array -> act
(* Build last minute sharing of action stuff *)
val make_catch : act -> int * (act -> act)
val make_exit : int -> act
sig
(* Standard entry point, sharing is tracked *)
val zyva :
- Location.t ->
+ Arg.loc ->
(int * int) ->
Arg.act ->
(int * int * int) array ->
[
"never", Never_inline;
"always", Always_inline;
+ "hint", Hint_inline;
]
payload
let check_local_inline loc attr =
match attr.local, attr.inline with
- | Always_local, (Always_inline | Unroll _) ->
+ | Always_local, (Always_inline | Hint_inline | Unroll _) ->
Location.prerr_warning loc
(Warnings.Duplicated_attribute "local/inline")
| _ ->
| Lfunction({ attr = { stub = false } as attr } as funct), inline ->
begin match attr.inline with
| Default_inline -> ()
- | Always_inline | Never_inline | Unroll _ ->
+ | Always_inline | Hint_inline | Never_inline | Unroll _ ->
Location.prerr_warning loc
(Warnings.Duplicated_attribute "inline")
end;
let attr = { attr with inline } in
check_local_inline loc attr;
Lfunction { funct with attr = attr }
- | expr, (Always_inline | Never_inline | Unroll _) ->
+ | expr, (Always_inline | Hint_inline | Never_inline | Unroll _) ->
Location.prerr_warning loc
(Warnings.Misplaced_attribute "inline");
expr
let inner_attr, me = get_and_remove me in
let attr =
match attr with
- | Always_inline | Never_inline | Unroll _ -> attr
+ | Always_inline | Hint_inline | Never_inline | Unroll _ -> attr
| Default_inline -> inner_attr
in
attr, Tmod_constraint (me, mt, mtc, mc)
open Lambda
open Translobj
open Translcore
+open Debuginfo.Scoped_location
(* XXX Rajouter des evenements... | Add more events... *)
Lfunction {kind = Curried; params; return = Pgenval;
body;
attr = default_function_attribute;
- loc = Location.none}
+ loc = Loc_unknown}
let lapply ap =
match ap.ap_func with
let mkappl (func, args) =
Lapply {ap_should_be_tailcall=false;
- ap_loc=Location.none;
+ ap_loc=Loc_unknown;
ap_func=func;
ap_args=args;
ap_inlined=Default_inline;
let lsequence l1 l2 =
if l2 = lambda_unit then l1 else Lsequence(l1, l2)
-let lfield v i = Lprim(Pfield i, [Lvar v], Location.none)
+let lfield v i = Lprim(Pfield i, [Lvar v], Loc_unknown)
let transl_label l = share (Const_immstring l)
share (Const_block
(0, List.map (fun lab -> Const_immstring lab) lst))
-let set_inst_var obj id expr =
+let set_inst_var ~scopes obj id expr =
Lprim(Psetfield_computed (Typeopt.maybe_pointer expr, Assignment),
- [Lvar obj; Lvar id; transl_exp expr], Location.none)
+ [Lvar obj; Lvar id; transl_exp ~scopes expr], Loc_unknown)
let transl_val tbl create name =
mkappl (oo_prim (if create then "new_variable" else "get_variable"),
| Tpat_alias(_, id, _) -> id
| _ -> Ident.create_local default
-let rec build_object_init cl_table obj params inh_init obj_init cl =
+let rec build_object_init ~scopes cl_table obj params inh_init obj_init cl =
match cl.cl_desc with
Tcl_ident (path, _, _) ->
let obj_init = Ident.create_local "obj_init" in
| Some envs ->
[Lprim(Pfield (List.length inh_init + 1),
[Lvar envs],
- Location.none)]
+ Loc_unknown)]
in
- let path_lam = transl_class_path cl.cl_loc cl.cl_env path in
+ let loc = of_location ~scopes cl.cl_loc in
+ let path_lam = transl_class_path loc cl.cl_env path in
((envs, (path, path_lam, obj_init) :: inh_init),
mkappl(Lvar obj_init, env @ [obj]))
| Tcl_structure str ->
match field.cf_desc with
Tcf_inherit (_, cl, _, _, _) ->
let (inh_init, obj_init') =
- build_object_init cl_table (Lvar obj) [] inh_init
+ build_object_init ~scopes cl_table (Lvar obj) [] inh_init
(fun _ -> lambda_unit) cl
in
(inh_init, lsequence obj_init' obj_init, true)
| Tcf_val (_, _, id, Tcfk_concrete (_, exp), _) ->
- (inh_init, lsequence (set_inst_var obj id exp) obj_init,
+ (inh_init,
+ lsequence (set_inst_var ~scopes obj id exp) obj_init,
has_init)
| Tcf_method _ | Tcf_val _ | Tcf_constraint _ | Tcf_attribute _->
(inh_init, obj_init, has_init)
(inh_init,
List.fold_right
(fun (id, expr) rem ->
- lsequence (Lifused (id, set_inst_var obj id expr)) rem)
+ lsequence (Lifused (id, set_inst_var ~scopes obj id expr)) rem)
params obj_init,
has_init))
| Tcl_fun (_, pat, vals, cl, partial) ->
let (inh_init, obj_init) =
- build_object_init cl_table obj (vals @ params) inh_init obj_init cl
+ build_object_init ~scopes cl_table obj (vals @ params)
+ inh_init obj_init cl
in
(inh_init,
let build params rem =
Lfunction {kind = Curried; params = (param, Pgenval)::params;
return = Pgenval;
attr = default_function_attribute;
- loc = pat.pat_loc;
- body = Matching.for_function
- pat.pat_loc None (Lvar param) [pat, rem] partial}
+ loc = of_location ~scopes pat.pat_loc;
+ body = Matching.for_function ~scopes pat.pat_loc
+ None (Lvar param) [pat, rem] partial}
in
begin match obj_init with
Lfunction {kind = Curried; params; body = rem} -> build params rem
end)
| Tcl_apply (cl, oexprs) ->
let (inh_init, obj_init) =
- build_object_init cl_table obj params inh_init obj_init cl
+ build_object_init ~scopes cl_table obj params inh_init obj_init cl
in
- (inh_init, transl_apply obj_init oexprs Location.none)
+ (inh_init, transl_apply ~scopes obj_init oexprs Loc_unknown)
| Tcl_let (rec_flag, defs, vals, cl) ->
let (inh_init, obj_init) =
- build_object_init cl_table obj (vals @ params) inh_init obj_init cl
+ build_object_init ~scopes cl_table obj (vals @ params)
+ inh_init obj_init cl
in
- (inh_init, Translcore.transl_let rec_flag defs obj_init)
+ (inh_init, Translcore.transl_let ~scopes rec_flag defs obj_init)
| Tcl_open (_, cl)
| Tcl_constraint (cl, _, _, _, _) ->
- build_object_init cl_table obj params inh_init obj_init cl
+ build_object_init ~scopes cl_table obj params inh_init obj_init cl
-let rec build_object_init_0 cl_table params cl copy_env subst_env top ids =
+let rec build_object_init_0
+ ~scopes cl_table params cl copy_env subst_env top ids =
match cl.cl_desc with
Tcl_let (_rec_flag, _defs, vals, cl) ->
- build_object_init_0 cl_table (vals@params) cl copy_env subst_env top ids
+ build_object_init_0
+ ~scopes cl_table (vals@params) cl copy_env subst_env top ids
| _ ->
let self = Ident.create_local "self" in
let env = Ident.create_local "env" in
let obj = if ids = [] then lambda_unit else Lvar self in
let envs = if top then None else Some env in
let ((_,inh_init), obj_init) =
- build_object_init cl_table obj params (envs,[]) copy_env cl in
+ build_object_init ~scopes cl_table obj params (envs,[]) copy_env cl in
let obj_init =
if ids = [] then obj_init else lfunction [self, Pgenval] obj_init in
(inh_init, lfunction [env, Pgenval] (subst_env env inh_init obj_init))
| _ ->
lsequence (mkappl(oo_prim "set_methods",
[Lvar tbl; Lprim(Pmakeblock(0,Immutable,None),
- methods, Location.none)]))
+ methods, Loc_unknown)]))
lam
let rec ignore_cstrs cl =
let bind_id_as_val (id, _) = ("", id)
-let rec build_class_init cla cstr super inh_init cl_init msubst top cl =
+let rec build_class_init ~scopes cla cstr super inh_init cl_init msubst top cl =
match cl.cl_desc with
| Tcl_ident _ ->
begin match inh_init with
| (_, path_lam, obj_init)::inh_init ->
(inh_init,
Llet (Strict, Pgenval, obj_init,
- mkappl(Lprim(Pfield 1, [path_lam], Location.none), Lvar cla ::
- if top then [Lprim(Pfield 3, [path_lam], Location.none)]
+ mkappl(Lprim(Pfield 1, [path_lam], Loc_unknown), Lvar cla ::
+ if top then [Lprim(Pfield 3, [path_lam], Loc_unknown)]
else []),
bind_super cla super cl_init))
| _ ->
Tcf_inherit (_, cl, _, vals, meths) ->
let cl_init = output_methods cla methods cl_init in
let inh_init, cl_init =
- build_class_init cla false
+ build_class_init ~scopes cla false
(vals, meths_super cla str.cstr_meths meths)
inh_init cl_init msubst top cl in
(inh_init, cl_init, [], values)
->
(inh_init, cl_init, methods, values)
| Tcf_method (name, _, Tcfk_concrete (_, exp)) ->
- let met_code = msubst true (transl_exp exp) in
+ let scopes = enter_method_definition ~scopes name.txt in
+ let met_code =
+ msubst true (transl_scoped_exp ~scopes exp) in
let met_code =
if !Clflags.native_code && List.length met_code = 1 then
(* Force correct naming of method for profiles *)
| Tcf_initializer exp ->
(inh_init,
Lsequence(mkappl (oo_prim "add_initializer",
- Lvar cla :: msubst false (transl_exp exp)),
+ Lvar cla :: msubst false
+ (transl_exp ~scopes exp)),
cl_init),
methods, values)
| Tcf_attribute _ ->
(inh_init, bind_methods cla str.cstr_meths values cl_init)
| Tcl_fun (_, _pat, vals, cl, _) ->
let (inh_init, cl_init) =
- build_class_init cla cstr super inh_init cl_init msubst top cl
+ build_class_init ~scopes cla cstr super inh_init cl_init msubst top cl
in
let vals = List.map bind_id_as_val vals in
(inh_init, transl_vals cla true StrictOpt vals cl_init)
| Tcl_apply (cl, _exprs) ->
- build_class_init cla cstr super inh_init cl_init msubst top cl
+ build_class_init ~scopes cla cstr super inh_init cl_init msubst top cl
| Tcl_let (_rec_flag, _defs, vals, cl) ->
let (inh_init, cl_init) =
- build_class_init cla cstr super inh_init cl_init msubst top cl
+ build_class_init ~scopes cla cstr super inh_init cl_init msubst top cl
in
let vals = List.map bind_id_as_val vals in
(inh_init, transl_vals cla true StrictOpt vals cl_init)
Llet(StrictOpt, Pgenval, obj_init, lfield inh 0, cl_init)))
| _ ->
let core cl_init =
- build_class_init cla true super inh_init cl_init msubst top cl
+ build_class_init
+ ~scopes cla true super inh_init cl_init msubst top cl
in
if cstr then core cl_init else
let (inh_init, cl_init) =
cl_init))
end
| Tcl_open (_, cl) ->
- build_class_init cla cstr super inh_init cl_init msubst top cl
+ build_class_init ~scopes cla cstr super inh_init cl_init msubst top cl
-let rec build_class_lets cl =
+let rec build_class_lets ~scopes cl =
match cl.cl_desc with
Tcl_let (rec_flag, defs, _vals, cl') ->
- let env, wrap = build_class_lets cl' in
+ let env, wrap = build_class_lets ~scopes cl' in
(env, fun x ->
- Translcore.transl_let rec_flag defs (wrap x))
+ Translcore.transl_let ~scopes rec_flag defs (wrap x))
| _ ->
(cl.cl_env, fun x -> x)
| Writing classes should be cheap
class c x y = d e f
*)
-let rec transl_class_rebind obj_init cl vf =
+let rec transl_class_rebind ~scopes obj_init cl vf =
match cl.cl_desc with
Tcl_ident (path, _, _) ->
if vf = Concrete then begin
try if (Env.find_class path cl.cl_env).cty_new = None then raise Exit
with Not_found -> raise Exit
end;
- let path_lam = transl_class_path cl.cl_loc cl.cl_env path in
+ let cl_loc = of_location ~scopes cl.cl_loc in
+ let path_lam = transl_class_path cl_loc cl.cl_env path in
(path, path_lam, obj_init)
| Tcl_fun (_, pat, _, cl, partial) ->
- let path, path_lam, obj_init = transl_class_rebind obj_init cl vf in
+ let path, path_lam, obj_init =
+ transl_class_rebind ~scopes obj_init cl vf in
let build params rem =
let param = name_pattern "param" pat in
Lfunction {kind = Curried; params = (param, Pgenval)::params;
return = Pgenval;
attr = default_function_attribute;
- loc = pat.pat_loc;
- body = Matching.for_function
- pat.pat_loc None (Lvar param) [pat, rem] partial}
+ loc = of_location ~scopes pat.pat_loc;
+ body = Matching.for_function ~scopes pat.pat_loc
+ None (Lvar param) [pat, rem] partial}
in
(path, path_lam,
match obj_init with
Lfunction {kind = Curried; params; body} -> build params body
| rem -> build [] rem)
| Tcl_apply (cl, oexprs) ->
- let path, path_lam, obj_init = transl_class_rebind obj_init cl vf in
- (path, path_lam, transl_apply obj_init oexprs Location.none)
+ let path, path_lam, obj_init =
+ transl_class_rebind ~scopes obj_init cl vf in
+ (path, path_lam, transl_apply ~scopes obj_init oexprs Loc_unknown)
| Tcl_let (rec_flag, defs, _vals, cl) ->
- let path, path_lam, obj_init = transl_class_rebind obj_init cl vf in
- (path, path_lam, Translcore.transl_let rec_flag defs obj_init)
+ let path, path_lam, obj_init =
+ transl_class_rebind ~scopes obj_init cl vf in
+ (path, path_lam, Translcore.transl_let ~scopes rec_flag defs obj_init)
| Tcl_structure _ -> raise Exit
| Tcl_constraint (cl', _, _, _, _) ->
- let path, path_lam, obj_init = transl_class_rebind obj_init cl' vf in
+ let path, path_lam, obj_init =
+ transl_class_rebind ~scopes obj_init cl' vf in
let rec check_constraint = function
Cty_constr(path', _, _) when Path.same path path' -> ()
| Cty_arrow (_, _, cty) -> check_constraint cty
check_constraint cl.cl_type;
(path, path_lam, obj_init)
| Tcl_open (_, cl) ->
- transl_class_rebind obj_init cl vf
+ transl_class_rebind ~scopes obj_init cl vf
-let rec transl_class_rebind_0 (self:Ident.t) obj_init cl vf =
+let rec transl_class_rebind_0 ~scopes (self:Ident.t) obj_init cl vf =
match cl.cl_desc with
Tcl_let (rec_flag, defs, _vals, cl) ->
let path, path_lam, obj_init =
- transl_class_rebind_0 self obj_init cl vf
+ transl_class_rebind_0 ~scopes self obj_init cl vf
in
- (path, path_lam, Translcore.transl_let rec_flag defs obj_init)
+ (path, path_lam, Translcore.transl_let ~scopes rec_flag defs obj_init)
| _ ->
- let path, path_lam, obj_init = transl_class_rebind obj_init cl vf in
+ let path, path_lam, obj_init =
+ transl_class_rebind ~scopes obj_init cl vf in
(path, path_lam, lfunction [self, Pgenval] obj_init)
-let transl_class_rebind cl vf =
+let transl_class_rebind ~scopes cl vf =
try
let obj_init = Ident.create_local "obj_init"
and self = Ident.create_local "self" in
let obj_init0 =
lapply {ap_should_be_tailcall=false;
- ap_loc=Location.none;
+ ap_loc=Loc_unknown;
ap_func=Lvar obj_init;
ap_args=[Lvar self];
ap_inlined=Default_inline;
ap_specialised=Default_specialise}
in
- let _, path_lam, obj_init' = transl_class_rebind_0 self obj_init0 cl vf in
+ let _, path_lam, obj_init' =
+ transl_class_rebind_0 ~scopes self obj_init0 cl vf in
let id = (obj_init' = lfunction [self, Pgenval] obj_init0) in
if id then path_lam else
[mkappl(Lvar env_init, [Lvar envs])]))));
lfield cla 2;
lfield cla 3],
- Location.none)))
+ Loc_unknown)))
with Exit ->
lambda_unit
| Levent _ | Lifused _ -> ()
in free l; !fv
-let transl_class ids cl_id pub_meths cl vflag =
+let transl_class ~scopes ids cl_id pub_meths cl vflag =
(* First check if it is not only a rebind *)
- let rebind = transl_class_rebind cl vflag in
+ let rebind = transl_class_rebind ~scopes cl vflag in
if rebind <> lambda_unit then rebind else
(* Prepare for heavy environment handling *)
+ let scopes = enter_class_definition ~scopes cl_id in
let tables = Ident.create_local (Ident.name cl_id ^ "_tables") in
let (top_env, req) = oo_add_class tables in
let top = not req in
- let cl_env, llets = build_class_lets cl in
+ let cl_env, llets = build_class_lets ~scopes cl in
let new_ids = if top then [] else Env.diff top_env cl_env in
let env2 = Ident.create_local "env" in
let meth_ids = get_class_meths cl in
Llet(Alias, Pgenval, env,
Lprim(Pfield_computed,
[Lvar self; Lvar env2],
- Location.none),
+ Loc_unknown),
body'))]
end
| _ -> assert false
if top then lambda_unit else
Lifused(env2, Lprim(Psetfield_computed (Pointer, Assignment),
[Lvar self; Lvar env2; Lvar env1'],
- Location.none))
+ Loc_unknown))
and subst_env envs l lam =
if top then lam else
(* must be called only once! *)
(* Now we start compiling the class *)
let cla = Ident.create_local "class" in
let (inh_init, obj_init) =
- build_object_init_0 cla [] cl copy_env subst_env top ids in
+ build_object_init_0 ~scopes cla [] cl copy_env subst_env top ids in
let inh_init' = List.rev inh_init in
let (inh_init', cl_init) =
- build_class_init cla true ([],[]) inh_init' obj_init msubst top cl
+ build_class_init ~scopes cla true ([],[]) inh_init' obj_init msubst top cl
in
assert (inh_init' = []);
let table = Ident.create_local "table"
and lclass lam =
let cl_init = llets (Lfunction{kind = Curried;
attr = default_function_attribute;
- loc = Location.none;
+ loc = Loc_unknown;
return = Pgenval;
params = [cla, Pgenval]; body = cl_init}) in
Llet(Strict, Pgenval, class_init, cl_init, lam (free_variables cl_init))
Lprim(Pmakeblock(0, Immutable, None),
[mkappl (Lvar env_init, [lambda_unit]);
Lvar class_init; Lvar env_init; lambda_unit],
- Location.none))))
+ Loc_unknown))))
and lbody_virt lenvs =
Lprim(Pmakeblock(0, Immutable, None),
[lambda_unit; Lfunction{kind = Curried;
attr = default_function_attribute;
- loc = Location.none;
+ loc = Loc_unknown;
return = Pgenval;
params = [cla, Pgenval]; body = cl_init};
lambda_unit; lenvs],
- Location.none)
+ Loc_unknown)
in
(* Still easy: a class defined at toplevel *)
if top && concrete then lclass lbody else
if !new_ids_meths = [] then lambda_unit else
Lprim(Pmakeblock(0, Immutable, None),
List.map (fun id -> Lvar id) !new_ids_meths,
- Location.none) in
+ Loc_unknown) in
if !new_ids_init = [] then menv else
Lprim(Pmakeblock(0, Immutable, None),
menv :: List.map (fun id -> Lvar id) !new_ids_init,
- Location.none)
+ Loc_unknown)
and linh_envs =
List.map
- (fun (_, path_lam, _) -> Lprim(Pfield 3, [path_lam], Location.none))
+ (fun (_, path_lam, _) -> Lprim(Pfield 3, [path_lam], Loc_unknown))
(List.rev inh_init)
in
let make_envs lam =
Llet(StrictOpt, Pgenval, envs,
(if linh_envs = [] then lenv else
Lprim(Pmakeblock(0, Immutable, None),
- lenv :: linh_envs, Location.none)),
+ lenv :: linh_envs, Loc_unknown)),
lam)
and def_ids cla lam =
Llet(StrictOpt, Pgenval, env2,
in
let inh_keys =
List.map
- (fun (_, path_lam, _) -> Lprim(Pfield 1, [path_lam], Location.none))
+ (fun (_, path_lam, _) -> Lprim(Pfield 1, [path_lam], Loc_unknown))
inh_paths
in
let lclass lam =
Lfunction{kind = Curried; params = [cla, Pgenval];
return = Pgenval;
attr = default_function_attribute;
- loc = Location.none;
+ loc = Loc_unknown;
body = def_ids cla cl_init}, lam)
and lcache lam =
if inh_keys = [] then Llet(Alias, Pgenval, cached, Lvar tables, lam) else
Llet(Strict, Pgenval, cached,
mkappl (oo_prim "lookup_tables",
[Lvar tables; Lprim(Pmakeblock(0, Immutable, None),
- inh_keys, Location.none)]),
+ inh_keys, Loc_unknown)]),
lam)
and lset cached i lam =
Lprim(Psetfield(i, Pointer, Assignment),
- [Lvar cached; lam], Location.none)
+ [Lvar cached; lam], Loc_unknown)
in
let ldirect () =
ltable cla
{
kind = Curried;
attr = default_function_attribute;
- loc = Location.none;
+ loc = Loc_unknown;
return = Pgenval;
params = [cla, Pgenval];
body = def_ids cla cl_init;
lfield cached 0;
lenvs]
else [lambda_unit; lfield cached 0; lambda_unit; lenvs]),
- Location.none
+ Loc_unknown
)))))
(* Wrapper for class compilation *)
let vflag = vf in
*)
-let transl_class ids id pub_meths cl vf =
- oo_wrap cl.cl_env false (transl_class ids id pub_meths cl) vf
+let transl_class ~scopes ids id pub_meths cl vf =
+ oo_wrap cl.cl_env false (transl_class ~scopes ids id pub_meths cl) vf
let () =
- transl_object := (fun id meths cl -> transl_class [] id meths cl Concrete)
+ transl_object := (fun ~scopes id meths cl ->
+ transl_class ~scopes [] id meths cl Concrete)
(* Error report *)
open Typedtree
open Lambda
+open Debuginfo.Scoped_location
val transl_class :
- Ident.t list -> Ident.t ->
+ scopes:scopes -> Ident.t list -> Ident.t ->
string list -> class_expr -> Asttypes.virtual_flag -> lambda;;
type error = Tags of string * string
open Typedtree
open Typeopt
open Lambda
+open Debuginfo.Scoped_location
type error =
Free_super_var
(* Forward declaration -- to be filled in by Translmod.transl_module *)
let transl_module =
- ref((fun _cc _rootpath _modl -> assert false) :
- module_coercion -> Path.t option -> module_expr -> lambda)
+ ref((fun ~scopes:_ _cc _rootpath _modl -> assert false) :
+ scopes:scopes -> module_coercion -> Path.t option ->
+ module_expr -> lambda)
let transl_object =
- ref (fun _id _s _cl -> assert false :
- Ident.t -> string list -> class_expr -> lambda)
+ ref (fun ~scopes:_ _id _s _cl -> assert false :
+ scopes:scopes -> Ident.t -> string list -> class_expr -> lambda)
(* Compile an exception/extension definition *)
let prim_fresh_oo_id =
Pccall (Primitive.simple ~name:"caml_fresh_oo_id" ~arity:1 ~alloc:false)
-let transl_extension_constructor env path ext =
+let transl_extension_constructor ~scopes env path ext =
let path =
Printtyp.wrap_printing_env env ~error:true (fun () ->
Option.map (Printtyp.rewrite_double_underscore_paths env) path)
| Some p, None -> Path.name p
| Some p, Some pack -> Printf.sprintf "%s.%s" pack (Path.name p)
in
- let loc = ext.ext_loc in
+ let loc = of_location ~scopes ext.ext_loc in
match ext.ext_kind with
Text_decl _ ->
Lprim (Pmakeblock (Obj.object_tag, Immutable, None),
- [Lconst (Const_base (Const_string (name, None)));
+ [Lconst (Const_base (Const_string (name, ext.ext_loc, None)));
Lprim (prim_fresh_oo_id, [Lconst (Const_base (Const_int 0))], loc)],
loc)
| Text_rebind(path, _lid) ->
let param = Typecore.name_cases "param" cases in
let desc =
{val_type = pat.pat_type; val_kind = Val_reg;
- val_attributes = []; Types.val_loc = Location.none; }
+ val_attributes = []; Types.val_loc = Location.none;
+ val_uid = Types.Uid.internal_not_actually_unique; }
in
let env = Env.add_value param desc exp.exp_env in
let name = Ident.name param in
let exp =
+ let cases =
+ let pure_case ({c_lhs; _} as case) =
+ {case with c_lhs = as_computation_pattern c_lhs} in
+ List.map pure_case cases in
{ exp with exp_loc = loc; exp_env = env; exp_desc =
Texp_match
({exp with exp_type = pat.pat_type; exp_env = env; exp_desc =
(* Insertion of debugging events *)
-let event_before = Translprim.event_before
+let event_before ~scopes exp lam =
+ Translprim.event_before (of_location ~scopes exp.exp_loc) exp lam
-let event_after = Translprim.event_after
+let event_after ~scopes exp lam =
+ Translprim.event_after (of_location ~scopes exp.exp_loc) exp lam
-let event_function exp lam =
+let event_function ~scopes exp lam =
if !Clflags.debug && not !Clflags.native_code then
let repr = Some (ref 0) in
let (info, body) = lam repr in
(info,
- Levent(body, {lev_loc = exp.exp_loc;
+ Levent(body, {lev_loc = of_location ~scopes exp.exp_loc;
lev_kind = Lev_function;
lev_repr = repr;
lev_env = exp.exp_env}))
(* Assertions *)
-let assert_failed exp =
+let assert_failed ~scopes exp =
let slot =
- transl_extension_path Location.none
+ transl_extension_path Loc_unknown
Env.initial_safe_string Predef.path_assert_failure
in
+ let loc = exp.exp_loc in
let (fname, line, char) =
- Location.get_pos_info exp.exp_loc.Location.loc_start
+ Location.get_pos_info loc.Location.loc_start
in
- Lprim(Praise Raise_regular, [event_after exp
+ let loc = of_location ~scopes exp.exp_loc in
+ Lprim(Praise Raise_regular, [event_after ~scopes exp
(Lprim(Pmakeblock(0, Immutable, None),
[slot;
Lconst(Const_block(0,
- [Const_base(Const_string (fname, None));
+ [Const_base(Const_string (fname, exp.exp_loc, None));
Const_base(Const_int line);
- Const_base(Const_int char)]))], exp.exp_loc))], exp.exp_loc)
+ Const_base(Const_int char)]))], loc))], loc)
;;
let rec cut n l =
| Val_prim p ->
Translprim.transl_primitive loc p env ty (Some path)
| Val_anc _ ->
- raise(Error(loc, Free_super_var))
+ raise(Error(to_location loc, Free_super_var))
| Val_reg | Val_self _ ->
transl_value_path loc env path
| _ -> fatal_error "Translcore.transl_exp: bad Texp_ident"
-let rec transl_exp e =
+let rec transl_exp ~scopes e =
List.iter (Translattribute.check_attribute e) e.exp_attributes;
let eval_once =
(* Whether classes for immediate objects must be cached *)
Texp_function _ | Texp_for _ | Texp_while _ -> false
| _ -> true
in
- if eval_once then transl_exp0 e else
- Translobj.oo_wrap e.exp_env true transl_exp0 e
+ if eval_once then transl_exp0 ~scopes e else
+ Translobj.oo_wrap e.exp_env true (transl_exp0 ~scopes) e
-and transl_exp0 e =
+and transl_exp0 ~scopes e =
match e.exp_desc with
| Texp_ident(path, _, desc) ->
- transl_ident e.exp_loc e.exp_env e.exp_type path desc
+ transl_ident (of_location ~scopes e.exp_loc)
+ e.exp_env e.exp_type path desc
| Texp_constant cst ->
Lconst(Const_base cst)
| Texp_let(rec_flag, pat_expr_list, body) ->
- transl_let rec_flag pat_expr_list (event_before body (transl_exp body))
+ transl_let ~scopes rec_flag pat_expr_list
+ (event_before ~scopes body (transl_exp ~scopes body))
| Texp_function { arg_label = _; param; cases; partial; } ->
- let ((kind, params, return), body) =
- event_function e
- (function repr ->
- let pl = push_defaults e.exp_loc [] cases partial in
- let return_kind = function_return_value_kind e.exp_env e.exp_type in
- transl_function e.exp_loc return_kind !Clflags.native_code repr
- partial param pl)
- in
- let attr = default_function_attribute in
- let loc = e.exp_loc in
- let lam = Lfunction{kind; params; return; body; attr; loc} in
- Translattribute.add_function_attributes lam loc e.exp_attributes
+ let scopes = enter_anonymous_function ~scopes in
+ transl_function ~scopes e param cases partial
| Texp_apply({ exp_desc = Texp_ident(path, _, {val_kind = Val_prim p});
exp_type = prim_type } as funct, oargs)
when List.length oargs >= p.prim_arity
let arg_exps =
List.map (function _, Some x -> x | _ -> assert false) argl
in
- let args = transl_list arg_exps in
+ let args = transl_list ~scopes arg_exps in
let prim_exp = if extra_args = [] then Some e else None in
let lam =
Translprim.transl_primitive_application
- e.exp_loc p e.exp_env prim_type path
+ (of_location ~scopes e.exp_loc) p e.exp_env prim_type path
prim_exp args arg_exps
in
if extra_args = [] then lam
Translattribute.get_and_remove_specialised_attribute funct
in
let e = { e with exp_desc = Texp_apply(funct, oargs) } in
- event_after e
- (transl_apply ~should_be_tailcall ~inlined ~specialised
- lam extra_args e.exp_loc)
+ event_after ~scopes e
+ (transl_apply ~scopes ~should_be_tailcall ~inlined ~specialised
+ lam extra_args (of_location ~scopes e.exp_loc))
end
| Texp_apply(funct, oargs) ->
let should_be_tailcall, funct =
Translattribute.get_and_remove_specialised_attribute funct
in
let e = { e with exp_desc = Texp_apply(funct, oargs) } in
- event_after e
- (transl_apply ~should_be_tailcall ~inlined ~specialised
- (transl_exp funct) oargs e.exp_loc)
+ event_after ~scopes e
+ (transl_apply ~scopes ~should_be_tailcall ~inlined ~specialised
+ (transl_exp ~scopes funct) oargs (of_location ~scopes e.exp_loc))
| Texp_match(arg, pat_expr_list, partial) ->
- transl_match e arg pat_expr_list partial
+ transl_match ~scopes e arg pat_expr_list partial
| Texp_try(body, pat_expr_list) ->
let id = Typecore.name_cases "exn" pat_expr_list in
- Ltrywith(transl_exp body, id,
- Matching.for_trywith (Lvar id) (transl_cases_try pat_expr_list))
+ Ltrywith(transl_exp ~scopes body, id,
+ Matching.for_trywith ~scopes (Lvar id)
+ (transl_cases_try ~scopes pat_expr_list))
| Texp_tuple el ->
- let ll, shape = transl_list_with_shape el in
+ let ll, shape = transl_list_with_shape ~scopes el in
begin try
Lconst(Const_block(0, List.map extract_constant ll))
with Not_constant ->
- Lprim(Pmakeblock(0, Immutable, Some shape), ll, e.exp_loc)
+ Lprim(Pmakeblock(0, Immutable, Some shape), ll,
+ (of_location ~scopes e.exp_loc))
end
| Texp_construct(_, cstr, args) ->
- let ll, shape = transl_list_with_shape args in
+ let ll, shape = transl_list_with_shape ~scopes args in
if cstr.cstr_inlined <> None then begin match ll with
| [x] -> x
| _ -> assert false
begin try
Lconst(Const_block(n, List.map extract_constant ll))
with Not_constant ->
- Lprim(Pmakeblock(n, Immutable, Some shape), ll, e.exp_loc)
+ Lprim(Pmakeblock(n, Immutable, Some shape), ll,
+ of_location ~scopes e.exp_loc)
end
| Cstr_extension(path, is_const) ->
- let lam = transl_extension_path e.exp_loc e.exp_env path in
+ let lam = transl_extension_path
+ (of_location ~scopes e.exp_loc) e.exp_env path in
if is_const then lam
else
Lprim(Pmakeblock(0, Immutable, Some (Pgenval :: shape)),
- lam :: ll, e.exp_loc)
+ lam :: ll, of_location ~scopes e.exp_loc)
end
| Texp_extension_constructor (_, path) ->
- transl_extension_path e.exp_loc e.exp_env path
+ transl_extension_path (of_location ~scopes e.exp_loc) e.exp_env path
| Texp_variant(l, arg) ->
let tag = Btype.hash_variant l in
begin match arg with
None -> Lconst(Const_pointer tag)
| Some arg ->
- let lam = transl_exp arg in
+ let lam = transl_exp ~scopes arg in
try
Lconst(Const_block(0, [Const_base(Const_int tag);
extract_constant lam]))
with Not_constant ->
Lprim(Pmakeblock(0, Immutable, None),
- [Lconst(Const_base(Const_int tag)); lam], e.exp_loc)
+ [Lconst(Const_base(Const_int tag)); lam],
+ of_location ~scopes e.exp_loc)
end
| Texp_record {fields; representation; extended_expression} ->
- transl_record e.exp_loc e.exp_env fields representation
- extended_expression
+ transl_record ~scopes e.exp_loc e.exp_env
+ fields representation extended_expression
| Texp_field(arg, _, lbl) ->
- let targ = transl_exp arg in
+ let targ = transl_exp ~scopes arg in
begin match lbl.lbl_repres with
Record_regular | Record_inlined _ ->
- Lprim (Pfield lbl.lbl_pos, [targ], e.exp_loc)
+ Lprim (Pfield lbl.lbl_pos, [targ],
+ of_location ~scopes e.exp_loc)
| Record_unboxed _ -> targ
- | Record_float -> Lprim (Pfloatfield lbl.lbl_pos, [targ], e.exp_loc)
+ | Record_float ->
+ Lprim (Pfloatfield lbl.lbl_pos, [targ],
+ of_location ~scopes e.exp_loc)
| Record_extension _ ->
- Lprim (Pfield (lbl.lbl_pos + 1), [targ], e.exp_loc)
+ Lprim (Pfield (lbl.lbl_pos + 1), [targ],
+ of_location ~scopes e.exp_loc)
end
| Texp_setfield(arg, _, lbl, newval) ->
let access =
| Record_extension _ ->
Psetfield (lbl.lbl_pos + 1, maybe_pointer newval, Assignment)
in
- Lprim(access, [transl_exp arg; transl_exp newval], e.exp_loc)
+ Lprim(access, [transl_exp ~scopes arg; transl_exp ~scopes newval],
+ of_location ~scopes e.exp_loc)
| Texp_array expr_list ->
let kind = array_kind e in
- let ll = transl_list expr_list in
+ let ll = transl_list ~scopes expr_list in
begin try
(* For native code the decision as to which compilation strategy to
use is made later. This enables the Flambda passes to lift certain
When not [Pfloatarray], the exception propagates to the handler
below. *)
let imm_array =
- Lprim (Pmakearray (kind, Immutable), ll, e.exp_loc)
+ Lprim (Pmakearray (kind, Immutable), ll,
+ of_location ~scopes e.exp_loc)
in
- Lprim (Pduparray (kind, Mutable), [imm_array], e.exp_loc)
+ Lprim (Pduparray (kind, Mutable), [imm_array],
+ of_location ~scopes e.exp_loc)
| cl ->
let imm_array =
match kind with
| Pgenarray ->
raise Not_constant (* can this really happen? *)
in
- Lprim (Pduparray (kind, Mutable), [imm_array], e.exp_loc)
+ Lprim (Pduparray (kind, Mutable), [imm_array],
+ of_location ~scopes e.exp_loc)
end
with Not_constant ->
- Lprim(Pmakearray (kind, Mutable), ll, e.exp_loc)
+ Lprim(Pmakearray (kind, Mutable), ll,
+ of_location ~scopes e.exp_loc)
end
| Texp_ifthenelse(cond, ifso, Some ifnot) ->
- Lifthenelse(transl_exp cond,
- event_before ifso (transl_exp ifso),
- event_before ifnot (transl_exp ifnot))
+ Lifthenelse(transl_exp ~scopes cond,
+ event_before ~scopes ifso (transl_exp ~scopes ifso),
+ event_before ~scopes ifnot (transl_exp ~scopes ifnot))
| Texp_ifthenelse(cond, ifso, None) ->
- Lifthenelse(transl_exp cond,
- event_before ifso (transl_exp ifso),
+ Lifthenelse(transl_exp ~scopes cond,
+ event_before ~scopes ifso (transl_exp ~scopes ifso),
lambda_unit)
| Texp_sequence(expr1, expr2) ->
- Lsequence(transl_exp expr1, event_before expr2 (transl_exp expr2))
+ Lsequence(transl_exp ~scopes expr1,
+ event_before ~scopes expr2 (transl_exp ~scopes expr2))
| Texp_while(cond, body) ->
- Lwhile(transl_exp cond, event_before body (transl_exp body))
+ Lwhile(transl_exp ~scopes cond,
+ event_before ~scopes body (transl_exp ~scopes body))
| Texp_for(param, _, low, high, dir, body) ->
- Lfor(param, transl_exp low, transl_exp high, dir,
- event_before body (transl_exp body))
- | Texp_send(_, _, Some exp) -> transl_exp exp
+ Lfor(param, transl_exp ~scopes low, transl_exp ~scopes high, dir,
+ event_before ~scopes body (transl_exp ~scopes body))
+ | Texp_send(_, _, Some exp) -> transl_exp ~scopes exp
| Texp_send(expr, met, None) ->
- let obj = transl_exp expr in
+ let obj = transl_exp ~scopes expr in
+ let loc = of_location ~scopes e.exp_loc in
let lam =
match met with
- Tmeth_val id -> Lsend (Self, Lvar id, obj, [], e.exp_loc)
+ Tmeth_val id -> Lsend (Self, Lvar id, obj, [], loc)
| Tmeth_name nm ->
let (tag, cache) = Translobj.meth obj nm in
let kind = if cache = [] then Public else Cached in
- Lsend (kind, tag, obj, cache, e.exp_loc)
+ Lsend (kind, tag, obj, cache, loc)
in
- event_after e lam
+ event_after ~scopes e lam
| Texp_new (cl, {Location.loc=loc}, _) ->
+ let loc = of_location ~scopes loc in
Lapply{ap_should_be_tailcall=false;
ap_loc=loc;
ap_func=
ap_inlined=Default_inline;
ap_specialised=Default_specialise}
| Texp_instvar(path_self, path, _) ->
- let self = transl_value_path e.exp_loc e.exp_env path_self in
- let var = transl_value_path e.exp_loc e.exp_env path in
- Lprim(Pfield_computed, [self; var], e.exp_loc)
+ let loc = of_location ~scopes e.exp_loc in
+ let self = transl_value_path loc e.exp_env path_self in
+ let var = transl_value_path loc e.exp_env path in
+ Lprim(Pfield_computed, [self; var], loc)
| Texp_setinstvar(path_self, path, _, expr) ->
- let self = transl_value_path e.exp_loc e.exp_env path_self in
- let var = transl_value_path e.exp_loc e.exp_env path in
- transl_setinstvar e.exp_loc self var expr
+ let loc = of_location ~scopes e.exp_loc in
+ let self = transl_value_path loc e.exp_env path_self in
+ let var = transl_value_path loc e.exp_env path in
+ transl_setinstvar ~scopes loc self var expr
| Texp_override(path_self, modifs) ->
- let self = transl_value_path e.exp_loc e.exp_env path_self in
+ let loc = of_location ~scopes e.exp_loc in
+ let self = transl_value_path loc e.exp_env path_self in
let cpy = Ident.create_local "copy" in
Llet(Strict, Pgenval, cpy,
Lapply{ap_should_be_tailcall=false;
- ap_loc=Location.none;
+ ap_loc=Loc_unknown;
ap_func=Translobj.oo_prim "copy";
ap_args=[self];
ap_inlined=Default_inline;
ap_specialised=Default_specialise},
List.fold_right
(fun (path, _, expr) rem ->
- let var = transl_value_path e.exp_loc e.exp_env path in
- Lsequence(transl_setinstvar Location.none
+ let var = transl_value_path loc e.exp_env path in
+ Lsequence(transl_setinstvar ~scopes Loc_unknown
(Lvar cpy) var expr, rem))
modifs
(Lvar cpy))
| Texp_letmodule(None, loc, Mp_present, modl, body) ->
- let lam = !transl_module Tcoerce_none None modl in
- Lsequence(Lprim(Pignore, [lam], loc.loc), transl_exp body)
+ let lam = !transl_module ~scopes Tcoerce_none None modl in
+ Lsequence(Lprim(Pignore, [lam], of_location ~scopes loc.loc),
+ transl_exp ~scopes body)
| Texp_letmodule(Some id, loc, Mp_present, modl, body) ->
let defining_expr =
- Levent (!transl_module Tcoerce_none None modl, {
- lev_loc = loc.loc;
+ let mod_scopes = enter_module_definition ~scopes id in
+ Levent (!transl_module ~scopes:mod_scopes Tcoerce_none None modl, {
+ lev_loc = of_location ~scopes loc.loc;
lev_kind = Lev_module_definition id;
lev_repr = None;
lev_env = Env.empty;
})
in
- Llet(Strict, Pgenval, id, defining_expr, transl_exp body)
+ Llet(Strict, Pgenval, id, defining_expr, transl_exp ~scopes body)
| Texp_letmodule(_, _, Mp_absent, _, body) ->
- transl_exp body
+ transl_exp ~scopes body
| Texp_letexception(cd, body) ->
Llet(Strict, Pgenval,
- cd.ext_id, transl_extension_constructor e.exp_env None cd,
- transl_exp body)
+ cd.ext_id, transl_extension_constructor ~scopes e.exp_env None cd,
+ transl_exp ~scopes body)
| Texp_pack modl ->
- !transl_module Tcoerce_none None modl
+ !transl_module ~scopes Tcoerce_none None modl
| Texp_assert {exp_desc=Texp_construct(_, {cstr_name="false"}, _)} ->
- assert_failed e
+ assert_failed ~scopes e
| Texp_assert (cond) ->
if !Clflags.noassert
then lambda_unit
- else Lifthenelse (transl_exp cond, lambda_unit, assert_failed e)
+ else Lifthenelse (transl_exp ~scopes cond, lambda_unit,
+ assert_failed ~scopes e)
| Texp_lazy e ->
(* when e needs no computation (constants, identifiers, ...), we
optimize the translation just as Lazy.lazy_from_val would
| `Constant_or_function ->
(* A constant expr (of type <> float if [Config.flat_float_array] is
true) gets compiled as itself. *)
- transl_exp e
+ transl_exp ~scopes e
| `Float_that_cannot_be_shortcut ->
(* We don't need to wrap with Popaque: this forward
block will never be shortcutted since it points to a float
and Config.flat_float_array is true. *)
Lprim(Pmakeblock(Obj.forward_tag, Immutable, None),
- [transl_exp e], e.exp_loc)
+ [transl_exp ~scopes e], of_location ~scopes e.exp_loc)
| `Identifier `Forward_value ->
(* CR-someday mshinwell: Consider adding a new primitive
that expresses the construction of forward_tag blocks.
value may subsequently turn into an immediate... *)
Lprim (Popaque,
[Lprim(Pmakeblock(Obj.forward_tag, Immutable, None),
- [transl_exp e], e.exp_loc)],
- e.exp_loc)
+ [transl_exp ~scopes e],
+ of_location ~scopes e.exp_loc)],
+ of_location ~scopes e.exp_loc)
| `Identifier `Other ->
- transl_exp e
+ transl_exp ~scopes e
| `Other ->
(* other cases compile to a lazy block holding a function *)
let fn = Lfunction {kind = Curried;
params= [Ident.create_local "param", Pgenval];
return = Pgenval;
attr = default_function_attribute;
- loc = e.exp_loc;
- body = transl_exp e} in
- Lprim(Pmakeblock(Config.lazy_tag, Mutable, None), [fn], e.exp_loc)
+ loc = of_location ~scopes e.exp_loc;
+ body = transl_exp ~scopes e} in
+ Lprim(Pmakeblock(Config.lazy_tag, Mutable, None), [fn],
+ of_location ~scopes e.exp_loc)
end
| Texp_object (cs, meths) ->
let cty = cs.cstr_type in
- let cl = Ident.create_local "class" in
- !transl_object cl meths
+ let cl = Ident.create_local "object" in
+ !transl_object ~scopes cl meths
{ cl_desc = Tcl_structure cs;
cl_loc = e.exp_loc;
cl_type = Cty_signature cty;
cl_attributes = [];
}
| Texp_letop{let_; ands; param; body; partial} ->
- event_after e
- (transl_letop e.exp_loc e.exp_env let_ ands param body partial)
+ event_after ~scopes e
+ (transl_letop ~scopes e.exp_loc e.exp_env let_ ands param body partial)
| Texp_unreachable ->
raise (Error (e.exp_loc, Unreachable_reached))
| Texp_open (od, e) ->
But since [scan_used_globals] runs before Simplif, we need to
do it. *)
begin match od.open_bound_items with
- | [] when pure = Alias -> transl_exp e
+ | [] when pure = Alias -> transl_exp ~scopes e
| _ ->
let oid = Ident.create_local "open" in
let body, _ =
List.fold_left (fun (body, pos) id ->
Llet(Alias, Pgenval, id,
- Lprim(Pfield pos, [Lvar oid], od.open_loc), body),
+ Lprim(Pfield pos, [Lvar oid],
+ of_location ~scopes od.open_loc), body),
pos + 1
- ) (transl_exp e, 0) (bound_value_identifiers od.open_bound_items)
+ ) (transl_exp ~scopes e, 0)
+ (bound_value_identifiers od.open_bound_items)
in
Llet(pure, Pgenval, oid,
- !transl_module Tcoerce_none None od.open_expr, body)
+ !transl_module ~scopes Tcoerce_none None od.open_expr, body)
end
and pure_module m =
| Tmod_constraint (m,_,_,_) -> pure_module m
| _ -> Strict
-and transl_list expr_list =
- List.map transl_exp expr_list
+and transl_list ~scopes expr_list =
+ List.map (transl_exp ~scopes) expr_list
-and transl_list_with_shape expr_list =
+and transl_list_with_shape ~scopes expr_list =
let transl_with_shape e =
let shape = Typeopt.value_kind e.exp_env e.exp_type in
- transl_exp e, shape
+ transl_exp ~scopes e, shape
in
List.split (List.map transl_with_shape expr_list)
-and transl_guard guard rhs =
- let expr = event_before rhs (transl_exp rhs) in
+and transl_guard ~scopes guard rhs =
+ let expr = event_before ~scopes rhs (transl_exp ~scopes rhs) in
match guard with
| None -> expr
| Some cond ->
- event_before cond (Lifthenelse(transl_exp cond, expr, staticfail))
+ event_before ~scopes cond
+ (Lifthenelse(transl_exp ~scopes cond, expr, staticfail))
-and transl_case {c_lhs; c_guard; c_rhs} =
- c_lhs, transl_guard c_guard c_rhs
+and transl_case ~scopes {c_lhs; c_guard; c_rhs} =
+ c_lhs, transl_guard ~scopes c_guard c_rhs
-and transl_cases cases =
+and transl_cases ~scopes cases =
let cases =
List.filter (fun c -> c.c_rhs.exp_desc <> Texp_unreachable) cases in
- List.map transl_case cases
+ List.map (transl_case ~scopes) cases
-and transl_case_try {c_lhs; c_guard; c_rhs} =
+and transl_case_try ~scopes {c_lhs; c_guard; c_rhs} =
iter_exn_names Translprim.add_exception_ident c_lhs;
Misc.try_finally
- (fun () -> c_lhs, transl_guard c_guard c_rhs)
+ (fun () -> c_lhs, transl_guard ~scopes c_guard c_rhs)
~always:(fun () ->
iter_exn_names Translprim.remove_exception_ident c_lhs)
-and transl_cases_try cases =
+and transl_cases_try ~scopes cases =
let cases =
List.filter (fun c -> c.c_rhs.exp_desc <> Texp_unreachable) cases in
- List.map transl_case_try cases
+ List.map (transl_case_try ~scopes) cases
-and transl_tupled_cases patl_expr_list =
+and transl_tupled_cases ~scopes patl_expr_list =
let patl_expr_list =
List.filter (fun (_,_,e) -> e.exp_desc <> Texp_unreachable)
patl_expr_list in
- List.map (fun (patl, guard, expr) -> (patl, transl_guard guard expr))
+ List.map (fun (patl, guard, expr) -> (patl, transl_guard ~scopes guard expr))
patl_expr_list
-and transl_apply ?(should_be_tailcall=false) ?(inlined = Default_inline)
+and transl_apply ~scopes ?(should_be_tailcall=false) ?(inlined = Default_inline)
?(specialised = Default_specialise) lam sargs loc =
let lapply funct args =
match funct with
- Lsend(k, lmet, lobj, largs, loc) ->
+ Lsend(k, lmet, lobj, largs, _) ->
Lsend(k, lmet, lobj, largs @ args, loc)
- | Levent(Lsend(k, lmet, lobj, largs, loc), _) ->
+ | Levent(Lsend(k, lmet, lobj, largs, _), _) ->
Lsend(k, lmet, lobj, largs @ args, loc)
| Lapply ap ->
Lapply {ap with ap_args = ap.ap_args @ args; ap_loc = loc}
lapply lam (List.rev_map fst args)
in
(build_apply lam [] (List.map (fun (l, x) ->
- Option.map transl_exp x, Btype.is_optional l)
+ Option.map (transl_exp ~scopes) x,
+ Btype.is_optional l)
sargs)
: Lambda.lambda)
-and transl_function loc return untuplify_fn repr partial (param:Ident.t) cases =
+and transl_function0
+ ~scopes loc return untuplify_fn repr partial (param:Ident.t) cases =
match cases with
[{c_lhs=pat; c_guard=None;
c_rhs={exp_desc = Texp_function { arg_label = _; param = param'; cases;
let kind = value_kind pat.pat_env pat.pat_type in
let return_kind = function_return_value_kind exp_env exp_type in
let ((_, params, return), body) =
- transl_function exp.exp_loc return_kind false repr partial' param' cases
+ transl_function0 ~scopes exp.exp_loc return_kind false
+ repr partial' param' cases
in
((Curried, (param, kind) :: params, return),
- Matching.for_function loc None (Lvar param) [pat, body] partial)
+ Matching.for_function ~scopes loc None (Lvar param)
+ [pat, body] partial)
| {c_lhs={pat_desc = Tpat_tuple pl}} :: _ when untuplify_fn ->
begin try
let size = List.length pl in
in
let params = List.map fst tparams in
((Tupled, tparams, return),
- Matching.for_tupled_function loc params
- (transl_tupled_cases pats_expr_list) partial)
+ Matching.for_tupled_function ~scopes loc params
+ (transl_tupled_cases ~scopes pats_expr_list) partial)
with Matching.Cannot_flatten ->
((Curried, [param, Pgenval], return),
- Matching.for_function loc repr (Lvar param)
- (transl_cases cases) partial)
+ Matching.for_function ~scopes loc repr (Lvar param)
+ (transl_cases ~scopes cases) partial)
end
| {c_lhs=pat} :: other_cases ->
let kind =
(value_kind pat.pat_env pat.pat_type) other_cases
in
((Curried, [param, kind], return),
- Matching.for_function loc repr (Lvar param)
- (transl_cases cases) partial)
+ Matching.for_function ~scopes loc repr (Lvar param)
+ (transl_cases ~scopes cases) partial)
| [] ->
(* With Camlp4, a pattern matching might be empty *)
((Curried, [param, Pgenval], return),
- Matching.for_function loc repr (Lvar param)
- (transl_cases cases) partial)
+ Matching.for_function ~scopes loc repr (Lvar param)
+ (transl_cases ~scopes cases) partial)
+
+and transl_function ~scopes e param cases partial =
+ let ((kind, params, return), body) =
+ event_function ~scopes e
+ (function repr ->
+ let pl = push_defaults e.exp_loc [] cases partial in
+ let return_kind = function_return_value_kind e.exp_env e.exp_type in
+ transl_function0 ~scopes e.exp_loc return_kind !Clflags.native_code
+ repr partial param pl)
+ in
+ let attr = default_function_attribute in
+ let loc = of_location ~scopes e.exp_loc in
+ let lam = Lfunction{kind; params; return; body; attr; loc} in
+ Translattribute.add_function_attributes lam e.exp_loc e.exp_attributes
+
+(* Like transl_exp, but used when introducing a new scope.
+ Goes to some trouble to avoid introducing many new anonymous function
+ scopes, as `let f a b = ...` is desugared to several Pexp_fun *)
+and transl_scoped_exp ~scopes expr =
+ match expr.exp_desc with
+ | Texp_function { arg_label = _; param; cases; partial } ->
+ transl_function ~scopes expr param cases partial
+ | _ ->
+ transl_exp ~scopes expr
+
+(* Calls transl_scoped_exp or transl_exp, according to whether a pattern
+ binding should introduce a new scope *)
+and transl_bound_exp ~scopes ~in_structure pat expr =
+ let should_introduce_scope =
+ match expr.exp_desc with
+ | Texp_function _ -> true
+ | _ when in_structure -> true
+ | _ -> false in
+ match pat_bound_idents pat with
+ | (id :: _) when should_introduce_scope ->
+ transl_scoped_exp ~scopes:(enter_value_definition ~scopes id) expr
+ | _ -> transl_exp ~scopes expr
(*
Notice: transl_let consumes (ie compiles) its pat_expr_list argument,
This complication allows choosing any compilation order for the
bindings and body of let constructs.
*)
-and transl_let rec_flag pat_expr_list =
+and transl_let ~scopes ?(in_structure=false) rec_flag pat_expr_list =
match rec_flag with
Nonrecursive ->
let rec transl = function
[] ->
fun body -> body
| {vb_pat=pat; vb_expr=expr; vb_attributes=attr; vb_loc} :: rem ->
- let lam = transl_exp expr in
+ let lam = transl_bound_exp ~scopes ~in_structure pat expr in
let lam = Translattribute.add_function_attributes lam vb_loc attr in
let mk_body = transl rem in
- fun body -> Matching.for_let pat.pat_loc lam pat (mk_body body)
+ fun body ->
+ Matching.for_let ~scopes pat.pat_loc lam pat (mk_body body)
in transl pat_expr_list
| Recursive ->
let idlist =
| Tpat_alias ({pat_desc=Tpat_any}, id,_) -> id
| _ -> assert false)
pat_expr_list in
- let transl_case {vb_expr=expr; vb_attributes; vb_loc} id =
- let lam = transl_exp expr in
+ let transl_case {vb_expr=expr; vb_attributes; vb_loc; vb_pat} id =
+ let lam = transl_bound_exp ~scopes ~in_structure vb_pat expr in
let lam =
Translattribute.add_function_attributes lam vb_loc vb_attributes
in
let lam_bds = List.map2 transl_case pat_expr_list idlist in
fun body -> Lletrec(lam_bds, body)
-and transl_setinstvar loc self var expr =
+and transl_setinstvar ~scopes loc self var expr =
Lprim(Psetfield_computed (maybe_pointer expr, Assignment),
- [self; var; transl_exp expr], loc)
+ [self; var; transl_exp ~scopes expr], loc)
-and transl_record loc env fields repres opt_init_expr =
+and transl_record ~scopes loc env fields repres opt_init_expr =
let size = Array.length fields in
(* Determine if there are "enough" fields (only relevant if this is a
functional-style record update *)
| Record_unboxed _ -> assert false
| Record_extension _ -> Pfield (i + 1)
| Record_float -> Pfloatfield i in
- Lprim(access, [Lvar init_id], loc), field_kind
+ Lprim(access, [Lvar init_id],
+ of_location ~scopes loc),
+ field_kind
| Overridden (_lid, expr) ->
let field_kind = value_kind expr.exp_env expr.exp_type in
- transl_exp expr, field_kind)
+ transl_exp ~scopes expr, field_kind)
fields
in
let ll, shape = List.split (Array.to_list lv) in
| Record_extension _ ->
raise Not_constant
with Not_constant ->
+ let loc = of_location ~scopes loc in
match repres with
Record_regular ->
Lprim(Pmakeblock(0, mut, Some shape), ll, loc)
begin match opt_init_expr with
None -> lam
| Some init_expr -> Llet(Strict, Pgenval, init_id,
- transl_exp init_expr, lam)
+ transl_exp ~scopes init_expr, lam)
end
end else begin
(* Take a shallow copy of the init record, then mutate the fields
| Record_extension _ ->
Psetfield(lbl.lbl_pos + 1, maybe_pointer expr, Assignment)
in
- Lsequence(Lprim(upd, [Lvar copy_id; transl_exp expr], loc), cont)
+ Lsequence(Lprim(upd, [Lvar copy_id; transl_exp ~scopes expr],
+ of_location ~scopes loc),
+ cont)
in
begin match opt_init_expr with
None -> assert false
| Some init_expr ->
Llet(Strict, Pgenval, copy_id,
- Lprim(Pduprecord (repres, size), [transl_exp init_expr], loc),
+ Lprim(Pduprecord (repres, size), [transl_exp ~scopes init_expr],
+ of_location ~scopes loc),
Array.fold_left update_field (Lvar copy_id) fields)
end
end
-and transl_match e arg pat_expr_list partial =
+and transl_match ~scopes e arg pat_expr_list partial =
let rewrite_case (val_cases, exn_cases, static_handlers as acc)
({ c_lhs; c_guard; c_rhs } as case) =
if c_rhs.exp_desc = Texp_unreachable then acc else
| None, None -> assert false
| Some pv, None ->
let val_case =
- transl_case { case with c_lhs = pv }
+ transl_case ~scopes { case with c_lhs = pv }
in
val_case :: val_cases, exn_cases, static_handlers
| None, Some pe ->
- let exn_case = transl_case_try { case with c_lhs = pe } in
+ let exn_case = transl_case_try ~scopes { case with c_lhs = pe } in
val_cases, exn_case :: exn_cases, static_handlers
| Some pv, Some pe ->
assert (c_guard = None);
iter_exn_names Translprim.add_exception_ident pe;
let rhs =
Misc.try_finally
- (fun () -> event_before c_rhs (transl_exp c_rhs))
+ (fun () -> event_before ~scopes c_rhs
+ (transl_exp ~scopes c_rhs))
~always:(fun () ->
iter_exn_names Translprim.remove_exception_ident pe)
in
let static_exception_id = next_raise_count () in
Lstaticcatch
(Ltrywith (Lstaticraise (static_exception_id, body), id,
- Matching.for_trywith (Lvar id) exn_cases),
+ Matching.for_trywith ~scopes (Lvar id) exn_cases),
(static_exception_id, val_ids),
handler)
in
match arg, exn_cases with
| {exp_desc = Texp_tuple argl}, [] ->
assert (static_handlers = []);
- Matching.for_multiple_match e.exp_loc (transl_list argl) val_cases partial
+ Matching.for_multiple_match ~scopes e.exp_loc
+ (transl_list ~scopes argl) val_cases partial
| {exp_desc = Texp_tuple argl}, _ :: _ ->
let val_ids =
List.map
argl
in
let lvars = List.map (fun (id, _) -> Lvar id) val_ids in
- static_catch (transl_list argl) val_ids
- (Matching.for_multiple_match e.exp_loc lvars val_cases partial)
+ static_catch (transl_list ~scopes argl) val_ids
+ (Matching.for_multiple_match ~scopes e.exp_loc
+ lvars val_cases partial)
| arg, [] ->
assert (static_handlers = []);
- Matching.for_function e.exp_loc None (transl_exp arg) val_cases partial
+ Matching.for_function ~scopes e.exp_loc
+ None (transl_exp ~scopes arg) val_cases partial
| arg, _ :: _ ->
- let val_id = Typecore.name_cases "val" pat_expr_list in
+ let val_id = Typecore.name_pattern "val" (List.map fst val_cases) in
let k = Typeopt.value_kind arg.exp_env arg.exp_type in
- static_catch [transl_exp arg] [val_id, k]
- (Matching.for_function e.exp_loc None (Lvar val_id) val_cases partial)
+ static_catch [transl_exp ~scopes arg] [val_id, k]
+ (Matching.for_function ~scopes e.exp_loc
+ None (Lvar val_id) val_cases partial)
in
List.fold_left (fun body (static_exception_id, val_ids, handler) ->
Lstaticcatch (body, (static_exception_id, val_ids), handler)
) classic static_handlers
-and transl_letop loc env let_ ands param case partial =
+and transl_letop ~scopes loc env let_ ands param case partial =
let rec loop prev_lam = function
| [] -> prev_lam
| and_ :: rest ->
let left_id = Ident.create_local "left" in
let right_id = Ident.create_local "right" in
let op =
- transl_ident and_.bop_op_name.loc env
+ transl_ident (of_location ~scopes and_.bop_op_name.loc) env
and_.bop_op_type and_.bop_op_path and_.bop_op_val
in
- let exp = transl_exp and_.bop_exp in
+ let exp = transl_exp ~scopes and_.bop_exp in
let lam =
bind Strict right_id exp
(Lapply{ap_should_be_tailcall = false;
- ap_loc = and_.bop_loc;
+ ap_loc = of_location ~scopes and_.bop_loc;
ap_func = op;
ap_args=[Lvar left_id; Lvar right_id];
ap_inlined=Default_inline;
bind Strict left_id prev_lam (loop lam rest)
in
let op =
- transl_ident let_.bop_op_name.loc env
+ transl_ident (of_location ~scopes let_.bop_op_name.loc) env
let_.bop_op_type let_.bop_op_path let_.bop_op_val
in
- let exp = loop (transl_exp let_.bop_exp) ands in
+ let exp = loop (transl_exp ~scopes let_.bop_exp) ands in
let func =
let return_kind = value_kind case.c_rhs.exp_env case.c_rhs.exp_type in
let (kind, params, return), body =
- event_function case.c_rhs
+ event_function ~scopes case.c_rhs
(function repr ->
- transl_function case.c_rhs.exp_loc return_kind
+ transl_function0 ~scopes case.c_rhs.exp_loc return_kind
!Clflags.native_code repr partial param [case])
in
let attr = default_function_attribute in
- let loc = case.c_rhs.exp_loc in
+ let loc = of_location ~scopes case.c_rhs.exp_loc in
Lfunction{kind; params; return; body; attr; loc}
in
Lapply{ap_should_be_tailcall = false;
- ap_loc = loc;
+ ap_loc = of_location ~scopes loc;
ap_func = op;
ap_args=[exp; func];
ap_inlined=Default_inline;
open Asttypes
open Typedtree
open Lambda
+open Debuginfo.Scoped_location
val pure_module : module_expr -> let_kind
-val transl_exp: expression -> lambda
-val transl_apply: ?should_be_tailcall:bool
+val transl_exp: scopes:scopes -> expression -> lambda
+val transl_apply: scopes:scopes
+ -> ?should_be_tailcall:bool
-> ?inlined:inline_attribute
-> ?specialised:specialise_attribute
-> lambda -> (arg_label * expression option) list
- -> Location.t -> lambda
-val transl_let: rec_flag -> value_binding list -> lambda -> lambda
+ -> scoped_location -> lambda
+val transl_let: scopes:scopes -> ?in_structure:bool -> rec_flag
+ -> value_binding list -> lambda -> lambda
-val transl_extension_constructor: Env.t -> Path.t option ->
+val transl_extension_constructor: scopes:scopes ->
+ Env.t -> Path.t option ->
extension_constructor -> lambda
+val transl_scoped_exp : scopes:scopes -> expression -> lambda
+
type error =
Free_super_var
| Unreachable_reached
(* Forward declaration -- to be filled in by Translmod.transl_module *)
val transl_module :
- (module_coercion -> Path.t option -> module_expr -> lambda) ref
+ (scopes:scopes -> module_coercion -> Path.t option ->
+ module_expr -> lambda) ref
val transl_object :
- (Ident.t -> string list -> class_expr -> lambda) ref
+ (scopes:scopes -> Ident.t -> string list ->
+ class_expr -> lambda) ref
open Translobj
open Translcore
open Translclass
+open Debuginfo.Scoped_location
type unsafe_component =
| Unsafe_module_binding
(* Compile type extensions *)
-let transl_type_extension env rootpath tyext body =
+let transl_type_extension ~scopes env rootpath tyext body =
List.fold_right
(fun ext body ->
let lam =
- transl_extension_constructor env (field_path rootpath ext.ext_id) ext
+ transl_extension_constructor ~scopes env
+ (field_path rootpath ext.ext_id) ext
in
Llet(Strict, Pgenval, ext.ext_id, lam, body))
tyext.tyext_constructors
let param = Ident.create_local "funarg" in
let carg = apply_coercion loc Alias cc_arg (Lvar param) in
apply_coercion_result loc strict arg [param, Pgenval] [carg] cc_res
- | Tcoerce_primitive { pc_loc; pc_desc; pc_env; pc_type; } ->
- Translprim.transl_primitive pc_loc pc_desc pc_env pc_type None
+ | Tcoerce_primitive { pc_loc = _; pc_desc; pc_env; pc_type; } ->
+ Translprim.transl_primitive loc pc_desc pc_env pc_type None
| Tcoerce_alias (env, path, cc) ->
let lam = transl_module_path loc env path in
name_lambda strict arg
let undefined_location loc =
let (fname, line, char) = Location.get_pos_info loc.Location.loc_start in
Lconst(Const_block(0,
- [Const_base(Const_string (fname, None));
+ [Const_base(Const_string (fname, loc, None));
Const_base(Const_int line);
Const_base(Const_int char)]))
type id_or_ignore_loc =
| Id of Ident.t
- | Ignore_loc of Location.t
+ | Ignore_loc of Lambda.scoped_location
let extract_unsafe_cycle id status init cycle_start =
let info i = match init.(i) with
| (Id id, Some(loc, shape), _rhs) :: rem ->
Llet(Strict, Pgenval, id,
Lapply{ap_should_be_tailcall=false;
- ap_loc=Location.none;
+ ap_loc=Loc_unknown;
ap_func=mod_prim "init_mod";
ap_args=[loc; shape];
ap_inlined=Default_inline;
patch_forwards rem
| (Id id, Some(_loc, shape), rhs) :: rem ->
Lsequence(Lapply{ap_should_be_tailcall=false;
- ap_loc=Location.none;
+ ap_loc=Loc_unknown;
ap_func=mod_prim "update_mod";
ap_args=[shape; Lvar id; rhs];
ap_inlined=Default_inline;
in
bind_inits bindings
-let compile_recmodule compile_rhs bindings cont =
+let compile_recmodule ~scopes compile_rhs bindings cont =
eval_rec_bindings
(reorder_rec_bindings
(List.map
(fun {mb_id=id; mb_name; mb_expr=modl; mb_loc=loc; _} ->
let id_or_ignore_loc, shape =
match id with
- | None -> Ignore_loc mb_name.loc, Result.Error Unnamed
+ | None ->
+ let loc = of_location ~scopes mb_name.loc in
+ Ignore_loc loc, Result.Error Unnamed
| Some id -> Id id, init_shape id modl
in
(id_or_ignore_loc, modl.mod_loc, shape, compile_rhs id modl loc))
(* Code to translate class entries in a structure *)
-let transl_class_bindings cl_list =
+let transl_class_bindings ~scopes cl_list =
let ids = List.map (fun (ci, _) -> ci.ci_id_class) cl_list in
(ids,
List.map
(fun ({ci_id_class=id; ci_expr=cl; ci_virt=vf}, meths) ->
- (id, transl_class ids id meths cl vf))
+ (id, transl_class ~scopes ids id meths cl vf))
cl_list)
(* Compile one or more functors, merging curried functors to produce
let merge_inline_attributes attr1 attr2 loc =
match Lambda.merge_inline_attributes attr1 attr2 with
| Some attr -> attr
- | None -> raise (Error (loc, Conflicting_inline_attributes))
+ | None -> raise (Error (to_location loc, Conflicting_inline_attributes))
-let merge_functors mexp coercion root_path =
- let rec merge mexp coercion path acc inline_attribute =
+let merge_functors ~scopes mexp coercion root_path =
+ let rec merge ~scopes mexp coercion path acc inline_attribute =
let finished = acc, mexp, path, coercion, inline_attribute in
match mexp.mod_desc with
| Tmod_functor (param, body) ->
arg_coercion, res_coercion
| _ -> fatal_error "Translmod.merge_functors: bad coercion"
in
- let loc = mexp.mod_loc in
+ let loc = of_location ~scopes mexp.mod_loc in
let path, param =
match param with
| Unit -> None, Ident.create_local "*"
let inline_attribute =
merge_inline_attributes inline_attribute inline_attribute' loc
in
- merge body res_coercion path ((param, loc, arg_coercion) :: acc)
+ merge ~scopes body res_coercion path ((param, loc, arg_coercion) :: acc)
inline_attribute
| _ -> finished
in
- merge mexp coercion root_path [] Default_inline
+ merge ~scopes mexp coercion root_path [] Default_inline
-let rec compile_functor mexp coercion root_path loc =
+let rec compile_functor ~scopes mexp coercion root_path loc =
let functor_params_rev, body, body_path, res_coercion, inline_attribute =
- merge_functors mexp coercion root_path
+ merge_functors ~scopes mexp coercion root_path
in
assert (List.length functor_params_rev >= 1); (* cf. [transl_module] *)
let params, body =
let params = (param', Pgenval) :: params in
let body = Llet (Alias, Pgenval, param, arg, body) in
params, body)
- ([], transl_module res_coercion body_path body)
+ ([], transl_module ~scopes res_coercion body_path body)
functor_params_rev
in
Lfunction {
(* Compile a module expression *)
-and transl_module cc rootpath mexp =
+and transl_module ~scopes cc rootpath mexp =
List.iter (Translattribute.check_attribute_on_module mexp)
mexp.mod_attributes;
- let loc = mexp.mod_loc in
+ let loc = of_location ~scopes mexp.mod_loc in
match mexp.mod_desc with
| Tmod_ident (path,_) ->
apply_coercion loc Strict cc
(transl_module_path loc mexp.mod_env path)
| Tmod_structure str ->
- fst (transl_struct loc [] cc rootpath str)
+ fst (transl_struct ~scopes loc [] cc rootpath str)
| Tmod_functor _ ->
oo_wrap mexp.mod_env true (fun () ->
- compile_functor mexp cc rootpath loc) ()
+ compile_functor ~scopes mexp cc rootpath loc) ()
| Tmod_apply(funct, arg, ccarg) ->
let inlined_attribute, funct =
Translattribute.get_and_remove_inlined_attribute_on_module funct
(apply_coercion loc Strict cc)
(Lapply{ap_should_be_tailcall=false;
ap_loc=loc;
- ap_func=transl_module Tcoerce_none None funct;
- ap_args=[transl_module ccarg None arg];
+ ap_func=transl_module ~scopes Tcoerce_none None funct;
+ ap_args=[transl_module ~scopes ccarg None arg];
ap_inlined=inlined_attribute;
ap_specialised=Default_specialise})
| Tmod_constraint(arg, _, _, ccarg) ->
- transl_module (compose_coercions cc ccarg) rootpath arg
+ transl_module ~scopes (compose_coercions cc ccarg) rootpath arg
| Tmod_unpack(arg, _) ->
- apply_coercion loc Strict cc (Translcore.transl_exp arg)
+ apply_coercion loc Strict cc (Translcore.transl_exp ~scopes arg)
-and transl_struct loc fields cc rootpath str =
- transl_structure loc fields cc rootpath str.str_final_env str.str_items
+and transl_struct ~scopes loc fields cc rootpath {str_final_env; str_items; _} =
+ transl_structure ~scopes loc fields cc rootpath str_final_env str_items
(* The function transl_structure is called by the bytecode compiler.
Some effort is made to compile in top to bottom order, in order to display
warning by increasing locations. *)
-and transl_structure loc fields cc rootpath final_env = function
+and transl_structure ~scopes loc fields cc rootpath final_env = function
[] ->
let body, size =
match cc with
(fun (pos, cc) ->
match cc with
Tcoerce_primitive p ->
- Translprim.transl_primitive p.pc_loc
+ Translprim.transl_primitive
+ (of_location ~scopes p.pc_loc)
p.pc_desc p.pc_env p.pc_type None
| _ -> apply_coercion loc Strict cc (get_field pos))
pos_cc_list, loc)
match item.str_desc with
| Tstr_eval (expr, _) ->
let body, size =
- transl_structure loc fields cc rootpath final_env rem
+ transl_structure ~scopes loc fields cc rootpath final_env rem
in
- Lsequence(transl_exp expr, body), size
+ Lsequence(transl_exp ~scopes expr, body), size
| Tstr_value(rec_flag, pat_expr_list) ->
(* Translate bindings first *)
- let mk_lam_let = transl_let rec_flag pat_expr_list in
+ let mk_lam_let =
+ transl_let ~scopes ~in_structure:true rec_flag pat_expr_list in
let ext_fields =
List.rev_append (let_bound_idents pat_expr_list) fields in
(* Then, translate remainder of struct *)
let body, size =
- transl_structure loc ext_fields cc rootpath final_env rem
+ transl_structure ~scopes loc ext_fields cc rootpath final_env rem
in
mk_lam_let body, size
| Tstr_primitive descr ->
record_primitive descr.val_val;
- transl_structure loc fields cc rootpath final_env rem
+ transl_structure ~scopes loc fields cc rootpath final_env rem
| Tstr_type _ ->
- transl_structure loc fields cc rootpath final_env rem
+ transl_structure ~scopes loc fields cc rootpath final_env rem
| Tstr_typext(tyext) ->
let ids = List.map (fun ext -> ext.ext_id) tyext.tyext_constructors in
let body, size =
- transl_structure loc (List.rev_append ids fields)
+ transl_structure ~scopes loc (List.rev_append ids fields)
cc rootpath final_env rem
in
- transl_type_extension item.str_env rootpath tyext body, size
+ transl_type_extension ~scopes item.str_env rootpath tyext body, size
| Tstr_exception ext ->
let id = ext.tyexn_constructor.ext_id in
let path = field_path rootpath id in
let body, size =
- transl_structure loc (id :: fields) cc rootpath final_env rem
+ transl_structure ~scopes loc (id::fields) cc rootpath final_env rem
in
Llet(Strict, Pgenval, id,
- transl_extension_constructor item.str_env
+ transl_extension_constructor ~scopes
+ item.str_env
path
ext.tyexn_constructor, body),
size
| Tstr_module ({mb_presence=Mp_present} as mb) ->
let id = mb.mb_id in
(* Translate module first *)
+ let subscopes = match id with
+ | None -> scopes
+ | Some id -> enter_module_definition ~scopes id in
let module_body =
- transl_module Tcoerce_none (Option.bind id (field_path rootpath))
- mb.mb_expr
+ transl_module ~scopes:subscopes Tcoerce_none
+ (Option.bind id (field_path rootpath)) mb.mb_expr
in
let module_body =
Translattribute.add_inline_attribute module_body mb.mb_loc
in
(* Translate remainder second *)
let body, size =
- transl_structure loc (cons_opt id fields) cc rootpath final_env rem
+ transl_structure ~scopes loc (cons_opt id fields)
+ cc rootpath final_env rem
in
begin match id with
| None ->
- Lsequence (Lprim(Pignore, [module_body], mb.mb_name.loc), body),
+ Lsequence (Lprim(Pignore, [module_body],
+ of_location ~scopes mb.mb_name.loc), body),
size
| Some id ->
let module_body =
Levent (module_body, {
- lev_loc = mb.mb_loc;
+ lev_loc = of_location ~scopes mb.mb_loc;
lev_kind = Lev_module_definition id;
lev_repr = None;
lev_env = Env.empty;
Llet(pure_module mb.mb_expr, Pgenval, id, module_body, body), size
end
| Tstr_module {mb_presence=Mp_absent} ->
- transl_structure loc fields cc rootpath final_env rem
+ transl_structure ~scopes loc fields cc rootpath final_env rem
| Tstr_recmodule bindings ->
let ext_fields =
List.rev_append (List.filter_map (fun mb -> mb.mb_id) bindings)
fields
in
let body, size =
- transl_structure loc ext_fields cc rootpath final_env rem
+ transl_structure ~scopes loc ext_fields cc rootpath final_env rem
in
let lam =
- compile_recmodule (fun id modl loc ->
+ compile_recmodule ~scopes (fun id modl loc ->
match id with
- | None -> transl_module Tcoerce_none None modl
+ | None -> transl_module ~scopes Tcoerce_none None modl
| Some id ->
let module_body =
- transl_module Tcoerce_none (field_path rootpath id) modl
+ transl_module
+ ~scopes:(enter_module_definition ~scopes id)
+ Tcoerce_none (field_path rootpath id) modl
in
Levent (module_body, {
- lev_loc = loc;
+ lev_loc = of_location ~scopes loc;
lev_kind = Lev_module_definition id;
lev_repr = None;
lev_env = Env.empty;
in
lam, size
| Tstr_class cl_list ->
- let (ids, class_bindings) = transl_class_bindings cl_list in
+ let (ids, class_bindings) = transl_class_bindings ~scopes cl_list in
let body, size =
- transl_structure loc (List.rev_append ids fields)
+ transl_structure ~scopes loc (List.rev_append ids fields)
cc rootpath final_env rem
in
Lletrec(class_bindings, body), size
let mid = Ident.create_local "include" in
let rec rebind_idents pos newfields = function
[] ->
- transl_structure loc newfields cc rootpath final_env rem
+ transl_structure ~scopes loc newfields cc rootpath final_env rem
| id :: ids ->
let body, size =
rebind_idents (pos + 1) (id :: newfields) ids
in
Llet(Alias, Pgenval, id,
- Lprim(Pfield pos, [Lvar mid], incl.incl_loc), body),
+ Lprim(Pfield pos, [Lvar mid],
+ of_location ~scopes incl.incl_loc), body),
size
in
let body, size = rebind_idents 0 fields ids in
Llet(pure_module modl, Pgenval, mid,
- transl_module Tcoerce_none None modl, body),
+ transl_module ~scopes Tcoerce_none None modl, body),
size
| Tstr_open od ->
it. *)
begin match od.open_bound_items with
| [] when pure = Alias ->
- transl_structure loc fields cc rootpath final_env rem
+ transl_structure ~scopes loc fields cc rootpath final_env rem
| _ ->
let ids = bound_value_identifiers od.open_bound_items in
let mid = Ident.create_local "open" in
let rec rebind_idents pos newfields = function
- [] ->
- transl_structure loc newfields cc rootpath final_env rem
+ [] -> transl_structure
+ ~scopes loc newfields cc rootpath final_env rem
| id :: ids ->
let body, size =
rebind_idents (pos + 1) (id :: newfields) ids
in
Llet(Alias, Pgenval, id,
- Lprim(Pfield pos, [Lvar mid], od.open_loc), body),
+ Lprim(Pfield pos, [Lvar mid],
+ of_location ~scopes od.open_loc), body),
size
in
let body, size = rebind_idents 0 fields ids in
Llet(pure, Pgenval, mid,
- transl_module Tcoerce_none None od.open_expr, body), size
+ transl_module ~scopes Tcoerce_none None od.open_expr, body),
+ size
end
| Tstr_modtype _
| Tstr_class_type _
| Tstr_attribute _ ->
- transl_structure loc fields cc rootpath final_env rem
+ transl_structure ~scopes loc fields cc rootpath final_env rem
(* Update forward declaration in Translcore *)
let _ =
primitive_declarations := [];
Translprim.clear_used_primitives ();
let module_id = Ident.create_persistent module_name in
+ let scopes = [Sc_module_definition module_name] in
let body, size =
Translobj.transl_label_init
- (fun () -> transl_struct Location.none [] cc
+ (fun () -> transl_struct ~scopes Loc_unknown [] cc
(global_path module_id) str)
in
{ module_ident = module_id;
in
let code =
Lprim (Psetglobal implementation.module_ident, [implementation.code],
- Location.none)
+ Loc_unknown)
in
{ implementation with code }
let ids = Array.of_list (defined_idents str.str_items) in
fun (pos, cc) ->
match cc with
- | Tcoerce_primitive { pc_loc; pc_desc; pc_env; pc_type; } ->
- Translprim.transl_primitive pc_loc pc_desc pc_env pc_type None
+ | Tcoerce_primitive { pc_loc = _; pc_desc; pc_env; pc_type; } ->
+ Translprim.transl_primitive loc pc_desc pc_env pc_type None
| Tcoerce_alias (env, path, cc) ->
let lam = transl_module_path loc env path in
apply_coercion loc Alias cc lam
| _ -> apply_coercion loc Strict cc (Lvar ids.(pos))
-let transl_store_structure glob map prims aliases str =
+let transl_store_structure ~scopes glob map prims aliases str =
let no_env_update _ _ env = env in
- let rec transl_store rootpath subst cont = function
+ let rec transl_store ~scopes rootpath subst cont = function
[] ->
transl_store_subst := subst;
Lambda.subst no_env_update subst cont
| item :: rem ->
match item.str_desc with
| Tstr_eval (expr, _attrs) ->
- Lsequence(Lambda.subst no_env_update subst (transl_exp expr),
- transl_store rootpath subst cont rem)
+ Lsequence(Lambda.subst no_env_update subst
+ (transl_exp ~scopes expr),
+ transl_store ~scopes rootpath subst cont rem)
| Tstr_value(rec_flag, pat_expr_list) ->
let ids = let_bound_idents pat_expr_list in
let lam =
- transl_let rec_flag pat_expr_list
- (store_idents Location.none ids)
+ transl_let ~scopes ~in_structure:true rec_flag pat_expr_list
+ (store_idents Loc_unknown ids)
in
Lsequence(Lambda.subst no_env_update subst lam,
- transl_store rootpath
+ transl_store ~scopes rootpath
(add_idents false ids subst) cont rem)
| Tstr_primitive descr ->
record_primitive descr.val_val;
- transl_store rootpath subst cont rem
+ transl_store ~scopes rootpath subst cont rem
| Tstr_type _ ->
- transl_store rootpath subst cont rem
+ transl_store ~scopes rootpath subst cont rem
| Tstr_typext(tyext) ->
let ids =
List.map (fun ext -> ext.ext_id) tyext.tyext_constructors
in
let lam =
- transl_type_extension item.str_env rootpath tyext
- (store_idents Location.none ids)
+ transl_type_extension ~scopes item.str_env rootpath tyext
+ (store_idents Loc_unknown ids)
in
Lsequence(Lambda.subst no_env_update subst lam,
- transl_store rootpath
+ transl_store ~scopes rootpath
(add_idents false ids subst) cont rem)
| Tstr_exception ext ->
let id = ext.tyexn_constructor.ext_id in
let path = field_path rootpath id in
+ let loc = of_location ~scopes ext.tyexn_constructor.ext_loc in
let lam =
- transl_extension_constructor item.str_env
+ transl_extension_constructor ~scopes
+ item.str_env
path
ext.tyexn_constructor
in
Lsequence(Llet(Strict, Pgenval, id,
Lambda.subst no_env_update subst lam,
- store_ident ext.tyexn_constructor.ext_loc id),
- transl_store rootpath
+ store_ident loc id),
+ transl_store ~scopes rootpath
(add_ident false id subst) cont rem)
| Tstr_module
{mb_id=None; mb_name; mb_presence=Mp_present; mb_expr=modl;
mb_loc=loc; mb_attributes} ->
let lam =
Translattribute.add_inline_attribute
- (transl_module Tcoerce_none None modl)
+ (transl_module ~scopes Tcoerce_none None modl)
loc mb_attributes
in
- Lsequence(Lprim(Pignore, [lam], mb_name.loc),
- transl_store rootpath subst cont rem)
+ Lsequence(
+ Lprim(Pignore,[Lambda.subst no_env_update subst lam],
+ of_location ~scopes mb_name.loc),
+ transl_store ~scopes rootpath subst cont rem
+ )
| Tstr_module{mb_id=Some id;mb_loc=loc;mb_presence=Mp_present;
mb_expr={mod_desc = Tmod_structure str} as mexp;
mb_attributes} ->
List.iter (Translattribute.check_attribute_on_module mexp)
mb_attributes;
+ let loc = of_location ~scopes loc in
let lam =
- transl_store (field_path rootpath id) subst
+ transl_store
+ ~scopes:(enter_module_definition ~scopes id)
+ (field_path rootpath id) subst
lambda_unit str.str_items
in
(* Careful: see next case *)
List.map (fun id -> Lvar id)
(defined_idents str.str_items), loc)),
Lsequence(store_ident loc id,
- transl_store rootpath
+ transl_store ~scopes rootpath
(add_ident true id subst)
cont rem)))
| Tstr_module{
Includemod.print_coercion cc; *)
List.iter (Translattribute.check_attribute_on_module mexp)
mb_attributes;
+ let loc = of_location ~scopes loc in
let lam =
- transl_store (field_path rootpath id) subst
+ transl_store
+ ~scopes:(enter_module_definition ~scopes id)
+ (field_path rootpath id) subst
lambda_unit str.str_items
in
(* Careful: see next case *)
(Lprim(Pmakeblock(0, Immutable, None),
List.map field map, loc)),
Lsequence(store_ident loc id,
- transl_store rootpath
+ transl_store ~scopes rootpath
(add_ident true id subst)
cont rem)))
| Tstr_module
mb_loc=loc; mb_attributes} ->
let lam =
Translattribute.add_inline_attribute
- (transl_module Tcoerce_none (field_path rootpath id) modl)
+ (transl_module
+ ~scopes:(enter_module_definition ~scopes id)
+ Tcoerce_none (field_path rootpath id) modl)
loc mb_attributes
in
(* Careful: the module value stored in the global may be different
If not, we can use the value from the global
(add_ident true adds id -> Pgetglobal... to subst). *)
Llet(Strict, Pgenval, id, Lambda.subst no_env_update subst lam,
- Lsequence(store_ident loc id,
- transl_store rootpath (add_ident true id subst)
+ Lsequence(store_ident (of_location ~scopes loc) id,
+ transl_store ~scopes rootpath
+ (add_ident true id subst)
cont rem))
| Tstr_module {mb_presence=Mp_absent} ->
- transl_store rootpath subst cont rem
+ transl_store ~scopes rootpath subst cont rem
| Tstr_recmodule bindings ->
let ids = List.filter_map (fun mb -> mb.mb_id) bindings in
- compile_recmodule
+ compile_recmodule ~scopes
(fun id modl _loc ->
Lambda.subst no_env_update subst
- (transl_module Tcoerce_none
- (Option.bind id (field_path rootpath)) modl))
+ (match id with
+ | None ->
+ transl_module ~scopes Tcoerce_none None modl
+ | Some id ->
+ transl_module
+ ~scopes:(enter_module_definition ~scopes id)
+ Tcoerce_none (field_path rootpath id) modl))
bindings
- (Lsequence(store_idents Location.none ids,
- transl_store rootpath (add_idents true ids subst)
- cont rem))
+ (Lsequence(store_idents Loc_unknown ids,
+ transl_store ~scopes rootpath
+ (add_idents true ids subst) cont rem))
| Tstr_class cl_list ->
- let (ids, class_bindings) = transl_class_bindings cl_list in
+ let (ids, class_bindings) = transl_class_bindings ~scopes cl_list in
let lam =
- Lletrec(class_bindings, store_idents Location.none ids)
+ Lletrec(class_bindings, store_idents Loc_unknown ids)
in
Lsequence(Lambda.subst no_env_update subst lam,
- transl_store rootpath (add_idents false ids subst)
+ transl_store ~scopes rootpath (add_idents false ids subst)
cont rem)
| Tstr_include{
(* Shouldn't we use mod_attributes instead of incl_attributes?
Same question for the Tstr_module cases above, btw. *)
let lam =
- transl_store None subst lambda_unit str.str_items
+ transl_store ~scopes None subst lambda_unit str.str_items
(* It is tempting to pass rootpath instead of None
in order to give a more precise name to exceptions
in the included structured, but this would introduce
a difference of behavior compared to bytecode. *)
in
let subst = !transl_store_subst in
- let field = field_of_str loc str in
+ let field = field_of_str (of_location ~scopes loc) str in
let ids0 = bound_value_identifiers incl_type in
let rec loop ids args =
match ids, args with
| [], [] ->
- transl_store rootpath (add_idents true ids0 subst)
+ transl_store ~scopes rootpath (add_idents true ids0 subst)
cont rem
| id :: ids, arg :: args ->
Llet(Alias, Pgenval, id,
Lambda.subst no_env_update subst (field arg),
- Lsequence(store_ident loc id,
+ Lsequence(store_ident (of_location ~scopes loc) id,
loop ids args))
| _ -> assert false
in
let mid = Ident.create_local "include" in
let loc = incl.incl_loc in
let rec store_idents pos = function
- | [] ->
- transl_store rootpath (add_idents true ids subst) cont rem
+ | [] -> transl_store
+ ~scopes rootpath (add_idents true ids subst) cont rem
| id :: idl ->
- Llet(Alias, Pgenval, id, Lprim(Pfield pos, [Lvar mid], loc),
- Lsequence(store_ident loc id,
+ Llet(Alias, Pgenval, id, Lprim(Pfield pos, [Lvar mid],
+ of_location ~scopes loc),
+ Lsequence(store_ident (of_location ~scopes loc) id,
store_idents (pos + 1) idl))
in
Llet(Strict, Pgenval, mid,
Lambda.subst no_env_update subst
- (transl_module Tcoerce_none None modl),
+ (transl_module ~scopes Tcoerce_none None modl),
store_idents 0 ids)
| Tstr_open od ->
begin match od.open_expr.mod_desc with
| Tmod_structure str ->
let lam =
- transl_store rootpath subst lambda_unit str.str_items
+ transl_store ~scopes rootpath subst lambda_unit str.str_items
in
+ let loc = of_location ~scopes od.open_loc in
let ids = Array.of_list (defined_idents str.str_items) in
let ids0 = bound_value_identifiers od.open_bound_items in
let subst = !transl_store_subst in
let rec store_idents pos = function
- | [] ->
- transl_store rootpath (add_idents true ids0 subst) cont rem
+ | [] -> transl_store ~scopes rootpath
+ (add_idents true ids0 subst) cont rem
| id :: idl ->
Llet(Alias, Pgenval, id, Lvar ids.(pos),
- Lsequence(store_ident od.open_loc id,
+ Lsequence(store_ident loc id,
store_idents (pos + 1) idl))
in
Lsequence(lam, Lambda.subst no_env_update subst
But since [scan_used_globals] runs before Simplif, we need to
do it. *)
match od.open_bound_items with
- | [] when pure = Alias -> transl_store rootpath subst cont rem
+ | [] when pure = Alias ->
+ transl_store ~scopes rootpath subst cont rem
| _ ->
let ids = bound_value_identifiers od.open_bound_items in
let mid = Ident.create_local "open" in
- let loc = od.open_loc in
+ let loc = of_location ~scopes od.open_loc in
let rec store_idents pos = function
- [] ->
- transl_store rootpath (add_idents true ids subst) cont
- rem
+ [] -> transl_store ~scopes rootpath
+ (add_idents true ids subst) cont rem
| id :: idl ->
Llet(Alias, Pgenval, id, Lprim(Pfield pos, [Lvar mid],
loc),
Lsequence(store_ident loc id,
store_idents (pos + 1) idl))
in
- Llet(pure, Pgenval, mid,
- Lambda.subst no_env_update subst
- (transl_module Tcoerce_none None od.open_expr),
- store_idents 0 ids)
+ Llet(
+ pure, Pgenval, mid,
+ Lambda.subst no_env_update subst
+ (transl_module ~scopes Tcoerce_none None od.open_expr),
+ store_idents 0 ids)
end
| Tstr_modtype _
| Tstr_class_type _
| Tstr_attribute _ ->
- transl_store rootpath subst cont rem
+ transl_store ~scopes rootpath subst cont rem
and store_ident loc id =
try
Tcoerce_none ->
Ident.Map.add id
(Lprim(Pfield pos,
- [Lprim(Pgetglobal glob, [], Location.none)],
- Location.none))
+ [Lprim(Pgetglobal glob, [], Loc_unknown)],
+ Loc_unknown))
subst
| _ ->
if may_coerce then subst else assert false
and store_primitive (pos, prim) cont =
Lsequence(Lprim(Psetfield(pos, Pointer, Root_initialization),
- [Lprim(Pgetglobal glob, [], Location.none);
- Translprim.transl_primitive Location.none
+ [Lprim(Pgetglobal glob, [], Loc_unknown);
+ Translprim.transl_primitive Loc_unknown
prim.pc_desc prim.pc_env prim.pc_type None],
- Location.none),
+ Loc_unknown),
cont)
and store_alias (pos, env, path, cc) =
- let path_lam = transl_module_path Location.none env path in
- let init_val = apply_coercion Location.none Strict cc path_lam in
+ let path_lam = transl_module_path Loc_unknown env path in
+ let init_val = apply_coercion Loc_unknown Strict cc path_lam in
Lprim(Psetfield(pos, Pointer, Root_initialization),
- [Lprim(Pgetglobal glob, [], Location.none);
+ [Lprim(Pgetglobal glob, [], Loc_unknown);
init_val],
- Location.none)
+ Loc_unknown)
in
let aliases = make_sequence store_alias aliases in
List.fold_right store_primitive prims
- (transl_store (global_path glob) !transl_store_subst aliases str)
+ (transl_store ~scopes (global_path glob) !transl_store_subst aliases str)
(* Transform a coercion and the list of value identifiers defined by
a toplevel structure into a table [id -> (pos, coercion)],
(* Compile an implementation using transl_store_structure
(for the native-code compiler). *)
-let transl_store_gen module_name ({ str_items = str }, restr) topl =
+let transl_store_gen ~scopes module_name ({ str_items = str }, restr) topl =
reset_labels ();
primitive_declarations := [];
Translprim.clear_used_primitives ();
let f = function
| [ { str_desc = Tstr_eval (expr, _attrs) } ] when topl ->
assert (size = 0);
- Lambda.subst (fun _ _ env -> env) !transl_store_subst (transl_exp expr)
- | str -> transl_store_structure module_id map prims aliases str
+ Lambda.subst (fun _ _ env -> env) !transl_store_subst
+ (transl_exp ~scopes expr)
+ | str -> transl_store_structure ~scopes module_id map prims aliases str
in
transl_store_label_init module_id size f str
(*size, transl_label_init (transl_store_structure module_id map prims str)*)
let transl_store_phrases module_name str =
- transl_store_gen module_name (str,Tcoerce_none) true
+ let scopes = [Sc_module_definition module_name] in
+ transl_store_gen ~scopes module_name (str,Tcoerce_none) true
let transl_store_implementation module_name (str, restr) =
let s = !transl_store_subst in
transl_store_subst := Ident.Map.empty;
- let (i, code) = transl_store_gen module_name (str, restr) false in
+ let module_ident = Ident.create_persistent module_name in
+ let scopes = [Sc_module_definition module_name] in
+ let (i, code) = transl_store_gen ~scopes module_name (str, restr) false in
transl_store_subst := s;
{ Lambda.main_module_block_size = i;
code;
(* module_ident is not used by closure, but this allow to share
the type with the flambda version *)
- module_ident = Ident.create_persistent module_name;
+ module_ident;
required_globals = required_globals ~flambda:true code }
(* Compile a toplevel phrase *)
let toploop_getvalue id =
Lapply{ap_should_be_tailcall=false;
- ap_loc=Location.none;
+ ap_loc=Loc_unknown;
ap_func=Lprim(Pfield toploop_getvalue_pos,
- [Lprim(Pgetglobal toploop_ident, [], Location.none)],
- Location.none);
- ap_args=[Lconst(Const_base(Const_string (toplevel_name id, None)))];
+ [Lprim(Pgetglobal toploop_ident, [], Loc_unknown)],
+ Loc_unknown);
+ ap_args=[Lconst(Const_base(
+ Const_string (toplevel_name id, Location.none,None)))];
ap_inlined=Default_inline;
ap_specialised=Default_specialise}
let toploop_setvalue id lam =
Lapply{ap_should_be_tailcall=false;
- ap_loc=Location.none;
+ ap_loc=Loc_unknown;
ap_func=Lprim(Pfield toploop_setvalue_pos,
- [Lprim(Pgetglobal toploop_ident, [], Location.none)],
- Location.none);
- ap_args=[Lconst(Const_base(Const_string (toplevel_name id, None)));
+ [Lprim(Pgetglobal toploop_ident, [], Loc_unknown)],
+ Loc_unknown);
+ ap_args=[Lconst(Const_base(
+ Const_string (toplevel_name id, Location.none, None)));
lam];
ap_inlined=Default_inline;
ap_specialised=Default_specialise}
toploop_getvalue id, l))
(free_variables lam) lam
-let transl_toplevel_item item =
+let transl_toplevel_item ~scopes item =
match item.str_desc with
Tstr_eval (expr, _)
| Tstr_value(Nonrecursive,
that Toploop can display the result of the expression.
Otherwise, the normal compilation would result
in a Lsequence returning unit. *)
- transl_exp expr
+ transl_exp ~scopes expr
| Tstr_value(rec_flag, pat_expr_list) ->
let idents = let_bound_idents pat_expr_list in
- transl_let rec_flag pat_expr_list
+ transl_let ~scopes ~in_structure:true rec_flag pat_expr_list
(make_sequence toploop_setvalue_id idents)
| Tstr_typext(tyext) ->
let idents =
(* we need to use unique name in case of multiple
definitions of the same extension constructor in the toplevel *)
List.iter set_toplevel_unique_name idents;
- transl_type_extension item.str_env None tyext
+ transl_type_extension ~scopes item.str_env None tyext
(make_sequence toploop_setvalue_id idents)
| Tstr_exception ext ->
set_toplevel_unique_name ext.tyexn_constructor.ext_id;
toploop_setvalue ext.tyexn_constructor.ext_id
- (transl_extension_constructor item.str_env None ext.tyexn_constructor)
+ (transl_extension_constructor ~scopes
+ item.str_env None ext.tyexn_constructor)
| Tstr_module {mb_id=None; mb_presence=Mp_present; mb_expr=modl} ->
- transl_module Tcoerce_none None modl
+ transl_module ~scopes Tcoerce_none None modl
| Tstr_module {mb_id=Some id; mb_presence=Mp_present; mb_expr=modl} ->
(* we need to use the unique name for the module because of issues
with "open" (PR#8133) *)
set_toplevel_unique_name id;
- let lam = transl_module Tcoerce_none (Some(Pident id)) modl in
+ let lam = transl_module
+ ~scopes:(enter_module_definition ~scopes id)
+ Tcoerce_none (Some(Pident id)) modl in
toploop_setvalue id lam
| Tstr_recmodule bindings ->
let idents = List.filter_map (fun mb -> mb.mb_id) bindings in
- compile_recmodule
+ compile_recmodule ~scopes
(fun id modl _loc ->
- transl_module Tcoerce_none (Option.map (fun i -> Pident i) id) modl)
+ match id with
+ | None ->
+ transl_module ~scopes Tcoerce_none None modl
+ | Some id ->
+ transl_module
+ ~scopes:(enter_module_definition ~scopes id)
+ Tcoerce_none (Some (Pident id)) modl)
bindings
(make_sequence toploop_setvalue_id idents)
| Tstr_class cl_list ->
(* we need to use unique names for the classes because there might
be a value named identically *)
- let (ids, class_bindings) = transl_class_bindings cl_list in
+ let (ids, class_bindings) = transl_class_bindings ~scopes cl_list in
List.iter set_toplevel_unique_name ids;
Lletrec(class_bindings, make_sequence toploop_setvalue_id ids)
| Tstr_include incl ->
lambda_unit
| id :: ids ->
Lsequence(toploop_setvalue id
- (Lprim(Pfield pos, [Lvar mid], Location.none)),
+ (Lprim(Pfield pos, [Lvar mid], Loc_unknown)),
set_idents (pos + 1) ids) in
Llet(Strict, Pgenval, mid,
- transl_module Tcoerce_none None modl, set_idents 0 ids)
+ transl_module ~scopes Tcoerce_none None modl, set_idents 0 ids)
| Tstr_primitive descr ->
record_primitive descr.val_val;
lambda_unit
lambda_unit
| id :: ids ->
Lsequence(toploop_setvalue id
- (Lprim(Pfield pos, [Lvar mid], Location.none)),
+ (Lprim(Pfield pos, [Lvar mid], Loc_unknown)),
set_idents (pos + 1) ids)
in
Llet(pure, Pgenval, mid,
- transl_module Tcoerce_none None od.open_expr, set_idents 0 ids)
+ transl_module ~scopes Tcoerce_none None od.open_expr,
+ set_idents 0 ids)
end
| Tstr_modtype _
| Tstr_module {mb_presence=Mp_absent}
| Tstr_attribute _ ->
lambda_unit
-let transl_toplevel_item_and_close itm =
+let transl_toplevel_item_and_close ~scopes itm =
close_toplevel_term
- (transl_label_init (fun () -> transl_toplevel_item itm, ()))
+ (transl_label_init (fun () -> transl_toplevel_item ~scopes itm, ()))
let transl_toplevel_definition str =
reset_labels ();
Translprim.clear_used_primitives ();
- make_sequence transl_toplevel_item_and_close str.str_items
+ make_sequence (transl_toplevel_item_and_close ~scopes:[]) str.str_items
(* Compile the initialization code for a packed library *)
let get_component = function
None -> Lconst const_unit
- | Some id -> Lprim(Pgetglobal id, [], Location.none)
+ | Some id -> Lprim(Pgetglobal id, [], Loc_unknown)
let transl_package_flambda component_names coercion =
let size =
| Tcoerce_alias _ -> assert false
in
size,
- apply_coercion Location.none Strict coercion
+ apply_coercion Loc_unknown Strict coercion
(Lprim(Pmakeblock(0, Immutable, None),
List.map get_component component_names,
- Location.none))
+ Loc_unknown))
let transl_package component_names target_name coercion =
let components =
Lprim(Pmakeblock(0, Immutable, None),
- List.map get_component component_names, Location.none) in
+ List.map get_component component_names, Loc_unknown) in
Lprim(Psetglobal target_name,
- [apply_coercion Location.none Strict coercion components],
- Location.none)
+ [apply_coercion Loc_unknown Strict coercion components],
+ Loc_unknown)
(*
let components =
match coercion with
make_sequence
(fun pos id ->
Lprim(Psetfield(pos, Pointer, Root_initialization),
- [Lprim(Pgetglobal target_name, [], Location.none);
+ [Lprim(Pgetglobal target_name, [], Loc_unknown);
get_component id],
- Location.none))
+ Loc_unknown))
0 component_names)
| Tcoerce_structure (pos_cc_list, _id_pos_list) ->
let components =
Lprim(Pmakeblock(0, Immutable, None),
List.map get_component component_names,
- Location.none)
+ Loc_unknown)
in
let blk = Ident.create_local "block" in
(List.length pos_cc_list,
Llet (Strict, Pgenval, blk,
- apply_coercion Location.none Strict coercion components,
+ apply_coercion Loc_unknown Strict coercion components,
make_sequence
(fun pos _id ->
Lprim(Psetfield(pos, Pointer, Root_initialization),
- [Lprim(Pgetglobal target_name, [], Location.none);
- Lprim(Pfield pos, [Lvar blk], Location.none)],
- Location.none))
+ [Lprim(Pgetglobal target_name, [], Loc_unknown);
+ Lprim(Pfield pos, [Lvar blk], Loc_unknown)],
+ Loc_unknown))
0 pos_cc_list))
(*
(* ignore id_pos_list as the ids are already bound *)
Llet (Strict, Pgenval, method_cache_id,
Lprim (Pccall prim_makearray,
[int !method_count; int 0],
- Location.none),
+ Loc_unknown),
expr)
in
transl_label_init_general (fun () -> expr, size)
assert(not Config.flambda);
assert(!Clflags.native_code);
method_cache := Lprim(Pfield size,
- [Lprim(Pgetglobal glob, [], Location.none)],
- Location.none);
+ [Lprim(Pgetglobal glob, [], Loc_unknown)],
+ Loc_unknown);
let expr = f arg in
let (size, expr) =
if !method_count = 0 then (size, expr) else
(size+1,
Lsequence(
Lprim(Psetfield(size, Pointer, Root_initialization),
- [Lprim(Pgetglobal glob, [], Location.none);
+ [Lprim(Pgetglobal glob, [], Loc_unknown);
Lprim (Pccall prim_makearray,
[int !method_count; int 0],
- Location.none)],
- Location.none),
+ Loc_unknown)],
+ Loc_unknown),
expr))
in
let lam, size = transl_label_init_general (fun () -> (expr, size)) in
Llet(StrictOpt, Pgenval, id,
Lprim(Pmakeblock(0, Mutable, None),
[lambda_unit; lambda_unit; lambda_unit],
- Location.none),
+ Loc_unknown),
lambda))
lambda !classes
in
open Typedtree
open Typeopt
open Lambda
+open Debuginfo.Scoped_location
type error =
| Unknown_builtin_primitive of string
(* Insertion of debugging events *)
-let event_before exp lam = match lam with
+let event_before loc exp lam = match lam with
| Lstaticraise (_,_) -> lam
| _ ->
if !Clflags.debug && not !Clflags.native_code
- then Levent(lam, {lev_loc = exp.exp_loc;
+ then Levent(lam, {lev_loc = loc;
lev_kind = Lev_before;
lev_repr = None;
lev_env = exp.exp_env})
else lam
-let event_after exp lam =
+let event_after loc exp lam =
if !Clflags.debug && not !Clflags.native_code
- then Levent(lam, {lev_loc = exp.exp_loc;
+ then Levent(lam, {lev_loc = loc;
lev_kind = Lev_after exp.exp_type;
lev_repr = None;
lev_env = exp.exp_env})
end
| _ -> None
-let unboxed_compare name native_repr =
- Primitive.make ~name ~alloc:false ~native_name:(name^"_unboxed")
- ~native_repr_args:[native_repr;native_repr] ~native_repr_res:Untagged_int
-
let caml_equal =
Primitive.simple ~name:"caml_equal" ~arity:2 ~alloc:true
let caml_string_equal =
Primitive.simple ~name:"caml_bytes_greaterthan" ~arity:2 ~alloc: false
let caml_compare =
Primitive.simple ~name:"caml_compare" ~arity:2 ~alloc:true
-let caml_int_compare =
- (* Not unboxed since the comparison is done directly on tagged int *)
- Primitive.simple ~name:"caml_int_compare" ~arity:2 ~alloc:false
-let caml_float_compare =
- unboxed_compare "caml_float_compare" Unboxed_float
let caml_string_compare =
Primitive.simple ~name:"caml_string_compare" ~arity:2 ~alloc:false
let caml_bytes_compare =
Primitive.simple ~name:"caml_bytes_compare" ~arity:2 ~alloc:false
-let caml_nativeint_compare =
- unboxed_compare "caml_nativeint_compare" (Unboxed_integer Pnativeint)
-let caml_int32_compare =
- unboxed_compare "caml_int32_compare" (Unboxed_integer Pint32)
-let caml_int64_compare =
- unboxed_compare "caml_int64_compare" (Unboxed_integer Pint64)
let comparison_primitive comparison comparison_kind =
match comparison, comparison_kind with
| Greater_than, Compare_int32s -> Pbintcomp(Pint32, Cgt)
| Greater_than, Compare_int64s -> Pbintcomp(Pint64, Cgt)
| Compare, Compare_generic -> Pccall caml_compare
- | Compare, Compare_ints -> Pccall caml_int_compare
- | Compare, Compare_floats -> Pccall caml_float_compare
+ | Compare, Compare_ints -> Pcompare_ints
+ | Compare, Compare_floats -> Pcompare_floats
| Compare, Compare_strings -> Pccall caml_string_compare
| Compare, Compare_bytes -> Pccall caml_bytes_compare
- | Compare, Compare_nativeints -> Pccall caml_nativeint_compare
- | Compare, Compare_int32s -> Pccall caml_int32_compare
- | Compare, Compare_int64s -> Pccall caml_int64_compare
+ | Compare, Compare_nativeints -> Pcompare_bints Pnativeint
+ | Compare, Compare_int32s -> Pcompare_bints Pint32
+ | Compare, Compare_int64s -> Pcompare_bints Pint64
let lambda_of_loc kind loc =
+ let loc = to_location loc in
let loc_start = loc.Location.loc_start in
let (file, lnum, cnum) = Location.get_pos_info loc_start in
let file =
let arg =
match arg_exps with
| None -> arg
- | Some [arg_exp] -> event_after arg_exp arg
+ | Some [arg_exp] -> event_after loc arg_exp arg
| Some _ -> assert false
in
Lprim(Praise kind, [arg], loc)
let raise_arg =
match arg_exps with
| None -> Lvar vexn
- | Some [exn_exp; _] -> event_after exn_exp (Lvar vexn)
+ | Some [exn_exp; _] -> event_after loc exn_exp (Lvar vexn)
| Some _ -> assert false
in
Llet(Strict, Pgenval, vexn, exn,
loc),
Lprim(Praise Raise_reraise, [raise_arg], loc)))
| Lazy_force, [arg] ->
- Matching.inline_lazy_force arg Location.none
+ Matching.inline_lazy_force arg Loc_unknown
| Loc kind, [] ->
lambda_of_loc kind loc
| Loc kind, [arg] ->
| (Raise _ | Raise_with_backtrace
| Lazy_force | Loc _ | Primitive _ | Comparison _
| Send | Send_self | Send_cache), _ ->
- raise(Error(loc, Wrong_arity_builtin_primitive prim_name))
+ raise(Error(to_location loc, Wrong_arity_builtin_primitive prim_name))
let check_primitive_arity loc p =
let prim = lookup_primitive loc p in
(* Eta-expand a primitive *)
let transl_primitive loc p env ty path =
- let prim = lookup_primitive_and_mark_used loc p env path in
+ let prim = lookup_primitive_and_mark_used (to_location loc) p env path in
let has_constant_constructor = false in
let prim =
match specialize_primitive env ty ~has_constant_constructor prim with
params;
return = Pgenval;
attr = default_stub_attribute;
- loc = loc;
- body = body; }
-
-(* Determine if a primitive is a Pccall or will be turned later into
- a C function call that may raise an exception *)
-let primitive_is_ccall = function
- | Pccall _ | Pstringrefs | Pbytesrefs | Pbytessets | Parrayrefs _ |
- Parraysets _ | Pbigarrayref _ | Pbigarrayset _ | Pduprecord _ | Pdirapply |
- Prevapply -> true
- | _ -> false
+ loc;
+ body; }
+
+let lambda_primitive_needs_event_after = function
+ | Prevapply | Pdirapply (* PR#6920 *)
+ (* We add an event after any primitive resulting in a C call that
+ may raise an exception or allocate. These are places where we may
+ collect the call stack. *)
+ | Pduprecord _ | Pccall _ | Pfloatofint | Pnegfloat | Pabsfloat
+ | Paddfloat | Psubfloat | Pmulfloat | Pdivfloat | Pstringrefs | Pbytesrefs
+ | Pbytessets | Pmakearray (Pgenarray, _) | Pduparray _
+ | Parrayrefu (Pgenarray | Pfloatarray) | Parraysetu (Pgenarray | Pfloatarray)
+ | Parrayrefs _ | Parraysets _ | Pbintofint _ | Pcvtbint _ | Pnegbint _
+ | Paddbint _ | Psubbint _ | Pmulbint _ | Pdivbint _ | Pmodbint _ | Pandbint _
+ | Porbint _ | Pxorbint _ | Plslbint _ | Plsrbint _ | Pasrbint _ | Pbintcomp _
+ | Pcompare_bints _
+ | Pbigarrayref _ | Pbigarrayset _ | Pbigarraydim _ | Pstring_load_16 _
+ | Pstring_load_32 _ | Pstring_load_64 _ | Pbytes_load_16 _ | Pbytes_load_32 _
+ | Pbytes_load_64 _ | Pbytes_set_16 _ | Pbytes_set_32 _ | Pbytes_set_64 _
+ | Pbigstring_load_16 _ | Pbigstring_load_32 _ | Pbigstring_load_64 _
+ | Pbigstring_set_16 _ | Pbigstring_set_32 _ | Pbigstring_set_64 _
+ | Pbbswap _ -> true
+
+ | Pidentity | Pbytes_to_string | Pbytes_of_string | Pignore | Psetglobal _
+ | Pgetglobal _ | Pmakeblock _ | Pfield _ | Pfield_computed | Psetfield _
+ | Psetfield_computed _ | Pfloatfield _ | Psetfloatfield _ | Praise _
+ | Psequor | Psequand | Pnot | Pnegint | Paddint | Psubint | Pmulint
+ | Pdivint _ | Pmodint _ | Pandint | Porint | Pxorint | Plslint | Plsrint
+ | Pasrint | Pintcomp _ | Poffsetint _ | Poffsetref _ | Pintoffloat
+ | Pcompare_ints | Pcompare_floats
+ | Pfloatcomp _ | Pstringlength | Pstringrefu | Pbyteslength | Pbytesrefu
+ | Pbytessetu | Pmakearray ((Pintarray | Paddrarray | Pfloatarray), _)
+ | Parraylength _ | Parrayrefu _ | Parraysetu _ | Pisint | Pisout
+ | Pintofbint _ | Pctconst _ | Pbswap16 | Pint_as_pointer | Popaque -> false
(* Determine if a primitive should be surrounded by an "after" debug event *)
let primitive_needs_event_after = function
- | Primitive (prim,_) -> primitive_is_ccall prim
+ | Primitive (prim,_) -> lambda_primitive_needs_event_after prim
| External _ -> true
| Comparison(comp, knd) ->
- primitive_is_ccall (comparison_primitive comp knd)
+ lambda_primitive_needs_event_after (comparison_primitive comp knd)
| Lazy_force | Send | Send_self | Send_cache -> true
| Raise _ | Raise_with_backtrace | Loc _ -> false
let transl_primitive_application loc p env ty path exp args arg_exps =
- let prim = lookup_primitive_and_mark_used loc p env (Some path) in
+ let prim =
+ lookup_primitive_and_mark_used (to_location loc) p env (Some path) in
let has_constant_constructor =
match arg_exps with
| [_; {exp_desc = Texp_construct(_, {cstr_tag = Cstr_constant _}, _)}]
if primitive_needs_event_after prim then begin
match exp with
| None -> lam
- | Some exp -> event_after exp lam
+ | Some exp -> event_after loc exp lam
end else begin
lam
end
(* Insertion of debugging events *)
-val event_before : Typedtree.expression -> Lambda.lambda -> Lambda.lambda
+val event_before : Lambda.scoped_location -> Typedtree.expression
+ -> Lambda.lambda -> Lambda.lambda
-val event_after : Typedtree.expression -> Lambda.lambda -> Lambda.lambda
+val event_after : Lambda.scoped_location -> Typedtree.expression
+ -> Lambda.lambda -> Lambda.lambda
(* Translation of primitives *)
val clear_used_primitives : unit -> unit
val get_used_primitives: unit -> Path.t list
-val check_primitive_arity : Location.t -> Primitive.description -> unit
+val check_primitive_arity :
+ Location.t -> Primitive.description -> unit
val transl_primitive :
- Location.t -> Primitive.description -> Env.t ->
+ Lambda.scoped_location -> Primitive.description -> Env.t ->
Types.type_expr -> Path.t option -> Lambda.lambda
val transl_primitive_application :
- Location.t -> Primitive.description -> Env.t ->
+ Lambda.scoped_location -> Primitive.description -> Env.t ->
Types.type_expr -> Path.t -> Typedtree.expression option ->
Lambda.lambda list -> Typedtree.expression list -> Lambda.lambda
ROOTDIR = ..
-include $(ROOTDIR)/Makefile.config
-include $(ROOTDIR)/Makefile.common
+-include $(ROOTDIR)/Makefile.config
+-include $(ROOTDIR)/Makefile.common
CAMLYACC ?= $(ROOTDIR)/yacc/ocamlyacc
clean::
rm -f ocamllex ocamllex.opt
- rm -f *.cmo *.cmi *.cmx *.cmt *.cmti *.$(O)
+ rm -f *.cmo *.cmi *.cmx *.cmt *.cmti *.o *.obj
parser.ml parser.mli: parser.mly
$(CAMLYACC) $(YACCFLAGS) parser.mly
let backslash_escapes =
['\\' '\'' '"' 'n' 't' 'b' 'r' ' ']
+let lowercase = ['a'-'z' '_']
+let ident = identstart identbody*
+let extattrident = ident ('.' ident)*
+let blank = [' ' '\009' '\012']
+
rule main = parse
[' ' '\013' '\009' '\012' ] +
{ main lexbuf }
handle_lexical_error comment lexbuf;
main lexbuf }
| '_' { Tunderscore }
- | identstart identbody *
+ | ident
{ match Lexing.lexeme lexbuf with
"rule" -> Trule
| "parse" -> Tparse
quoted_string delim lexbuf }
| eof
{ raise (Lexical_error ("unterminated string", "", 0, 0)) }
- | '|' (['a'-'z' '_'] * as delim') '}'
+ | '|' (lowercase* as delim') '}'
{ if delim <> delim' then
quoted_string delim lexbuf }
| _
string lexbuf;
reset_string_buffer();
comment lexbuf }
- | '{' (['a'-'z' '_'] * as delim) '|'
+ | '{' ('%' '%'? extattrident blank*)? (lowercase* as delim) "|"
{ quoted_string delim lexbuf;
comment lexbuf }
| "'"
| '\010'
{ incr_loc lexbuf 0;
comment lexbuf }
- | identstart identbody *
+ | ident
{ comment lexbuf }
| _
{ comment lexbuf }
handle_lexical_error string lexbuf;
reset_string_buffer();
action lexbuf }
- | '{' (['a'-'z' '_'] * as delim) '|'
+ | '{' ('%' '%'? extattrident blank*)? (lowercase* as delim) "|"
{ quoted_string delim lexbuf;
action lexbuf }
| "'"
| '\010'
{ incr_loc lexbuf 0;
action lexbuf }
- | identstart identbody *
+ | ident
{ action lexbuf }
| _
{ action lexbuf }
Show absolute filenames in error messages.
.TP
.B \-annot
-Dump detailed information about the compilation (types, bindings,
-tail-calls, etc). The information for file
-.IR src .ml
-is put into file
-.IR src .annot.
-In case of a type error, dump all the information inferred by the
-type-checker before the error. The
-.IR src .annot
-file can be used with the emacs commands given in
-.B emacs/caml\-types.el
-to display types and other annotations interactively.
+Deprecated since 4.11. Please use
+.BR \-bin-annot
+instead.
.TP
.B \-bin\-annot
Dump detailed information about the compilation (types, bindings,
Each warning can be
.IR enabled \ or\ disabled ,
and each warning can be
-.IR fatal or
+.IR fatal \ or
.IR non-fatal .
If a warning is disabled, it isn't displayed and doesn't affect
compilation in any way (even if it is fatal). If a warning is enabled,
\ \ \ Label omitted in function application.
7
-\ \ \ Method overridden without using the "method!" keyword
+\ \ \ Method overridden without using the "method!" keyword.
8
\ \ \ Partial match: missing cases in pattern-matching.
\ \ Unannotated unboxable type in primitive declaration.
62
-\ \ Type constraint on GADT type declaration
+\ \ Type constraint on GADT type declaration.
63
-\ \ Erroneous printed signature
+\ \ Erroneous printed signature.
64
-\ \ -unsafe used with a preprocessor returning a syntax tree
+\ \ -unsafe used with a preprocessor returning a syntax tree.
65
-\ \ Type declaration defining a new '()' constructor
+\ \ Type declaration defining a new '()' constructor.
66
\ \ Unused open! statement.
+67
+\ \ Unused functor parameter.
+
The letters stand for the following sets of warnings. Any letter not
mentioned here corresponds to the empty set.
.B \-I
options that are passed to the compiler.
.TP
+.B \-nocwd
+Do not add current working directory to the list of include directories.
+.TP
.BI \-impl \ file
Process
.IR file
Show absolute filenames in error messages.
.TP
.B \-annot
-Dump detailed information about the compilation (types, bindings,
-tail-calls, etc). The information for file
-.IR src .ml
-is put into file
-.IR src .annot.
-In case of a type error, dump all the information inferred by the
-type-checker before the error. The
-.IR src .annot
-file can be used with the emacs commands given in
-.B emacs/caml\-types.el
-to display types and other annotations interactively.
+Deprecated since OCaml 4.11. Please use
+.BR \-bin-annot
+instead.
.TP
.B \-bin\-annot
Dump detailed information about the compilation (types, bindings,
.B \-fno\-PIC
Generate position-dependent machine code.
+.SH OPTIONS FOR THE POWER ARCHITECTURE
+
+The PowerPC code generator supports the following additional options:
+.TP
+.B \-flarge\-toc
+Enables the PowerPC large model allowing the TOC (table of contents) to be
+arbitrarily large. This is the default since 4.11.
+.TP
+.B \-fsmall\-toc
+Enables the PowerPC small model allowing the TOC to be up to 64 kbytes per
+compilation unit. Prior to 4.11 this was the default behaviour.
+\end{options}
+
.SH OPTIONS FOR THE ARM ARCHITECTURE
The ARM code generator supports the following additional options:
.TP
- Optimisation with Flambda: `flambda.etex`
- Memory profiling with Spacetime: `spacetime-chapter.etex`
- Fuzzing with afl-fuzz: `afl-fuzz.etex`
+ - Runtime tracing with the instrumented runtime: `instrumented-runtime.etex`
Note that ocamlc,ocamlopt and the toplevel options overlap a lot.
Consequently, these options are described together in the file
\cleardoublepage
\setcounter{page}{1}
-
\begin{htmlonly}
\begin{quote}
\rule{}{}
This manual is also available in
-\ahref{http://caml.inria.fr/distrib/ocaml-\ocamlversion/ocaml-\ocamlversion-refman.pdf}{PDF}.
-\ahref{http://caml.inria.fr/distrib/ocaml-\ocamlversion/ocaml-\ocamlversion-refman.txt}{plain text},
+\ahref{https://ocaml.org/releases/\ocamlversion/ocaml-\ocamlversion-refman.pdf}{PDF}.
+\ahref{https://ocaml.org/releases/\ocamlversion/ocaml-\ocamlversion-refman.txt}{plain text},
as a
-\ahref{http://caml.inria.fr/distrib/ocaml-\ocamlversion/ocaml-\ocamlversion-refman-html.tar.gz}{bundle of HTML files},
+\ahref{https://ocaml.org/releases/\ocamlversion/ocaml-\ocamlversion-refman-html.tar.gz}{bundle of HTML files},
and as a
-\ahref{http://caml.inria.fr/distrib/ocaml-\ocamlversion/ocaml-\ocamlversion-refman.info.tar.gz}{bundle of Emacs Info files}.
+\ahref{https://ocaml.org/releases/\ocamlversion/ocaml-\ocamlversion-refman.info.tar.gz}{bundle of Emacs Info files}.
\rule{}{}
\end{quote}
\end{htmlonly}
\input{flambda.tex}
\input{spacetime-chapter.tex}
\input{afl-fuzz.tex}
+\input{instrumented-runtime.tex}
\part{The OCaml library}
\label{p:library}
FILES = comp.tex top.tex runtime.tex native.tex lexyacc.tex intf-c.tex \
ocamldep.tex profil.tex debugger.tex browser.tex ocamldoc.tex \
warnings-help.tex ocamlbuild.tex flambda.tex spacetime-chapter.tex \
- afl-fuzz.tex unified-options.tex
+ afl-fuzz.tex instrumented-runtime.tex unified-options.tex
WITH_TRANSF = top.tex intf-c.tex flambda.tex spacetime-chapter.tex \
afl-fuzz.tex lexyacc.tex debugger.tex
-WITH_CAMLEXAMPLE = ocamldoc.tex
+WITH_CAMLEXAMPLE = instrumented-runtime.tex ocamldoc.tex
etex-files: $(FILES)
\var{frag} is the identifier of a code fragment, a set of modules that
have been loaded at once, either initially or with the "Dynlink"
module. The integer \var{pc} is the instruction counter within this
-code fragment. If \var{frag} is ommited, it defaults to 0, which is
+code fragment. If \var{frag} is omitted, it defaults to 0, which is
the code fragment of the program loaded initially.
\item["delete "\optvar{breakpoint-numbers}]
attributes at call sites override any other attribute that may be present
on the corresponding declaration.
{\machine{\@inlined}} with no argument is equivalent to
-{\machine{\@inlined always}}.
+{\machine{\@inlined always}}. {\machine{\@\@inlined hint}} is equivalent to
+{\machine{\@\@inline always}} except that it will not trigger warning 55 if
+the function application cannot be inlined.
\end{options}
For recursive functions the relevant attributes are:
--- /dev/null
+\chapter{Runtime tracing with the instrumented runtime}
+%HEVEA\cutname{instrumented-runtime.html}
+
+This chapter describes the OCaml instrumented runtime, a runtime variant
+allowing the collection of events and metrics.
+
+Collected metrics include time spent executing the {\em garbage collector}.
+The overall execution time of individual pauses are measured
+down to the time spent in specific parts of the garbage collection.
+Insight is also given on memory allocation and motion by recording
+the size of allocated memory blocks, as well as value promotions from the
+{\em minor heap} to the {\em major heap}.
+
+\section{s:instr-runtime-overview}{Overview}
+
+Once compiled and linked with the instrumented runtime, any OCaml program
+can generate {\em trace files} that can then be read
+and analyzed by users in order to understand specific runtime behaviors.
+
+The generated trace files are stored using the {\em Common Trace Format}, which
+is a general purpose binary tracing format.
+A complete trace consists of:
+\begin{itemize}
+\item a {\em metadata file}, part of the OCaml distribution
+\item and a {\em trace file}, generated by the runtime\
+ in the program being traced.
+\end{itemize}
+
+For more information on the {\em Common Trace Format}, see
+\href{https://diamon.org/ctf/}{https://diamon.org/ctf/}.
+
+\section{s:instr-runtime-enabling}{Enabling runtime instrumentation}
+
+
+For the following examples, we will use the following example program:
+
+\begin{caml_example*}{verbatim}
+module SMap = Map.Make(String)
+
+let s i = String.make 512 (Char.chr (i mod 256))
+
+let clear map = SMap.fold (fun k _ m -> SMap.remove k m) map map
+
+let rec seq i =
+ if i = 0 then Seq.empty else fun () -> (Seq.Cons (i, seq (i - 1)))
+
+let () =
+ seq 1_000_000
+ |> Seq.fold_left (fun m i -> SMap.add (s i) i m) SMap.empty
+ |> clear
+ |> ignore
+\end{caml_example*}
+
+The next step is to compile and link the program with the instrumented runtime.
+This can be done by using the "-runtime-variant" flag:
+
+\begin{verbatim}
+ ocamlopt -runtime-variant i program.ml -o program
+\end{verbatim}
+
+Note that the instrumented runtime is an alternative runtime for OCaml
+programs. It is only referenced during the linking stage of the final
+executable. This means that the compilation stage does not need to be altered
+to enable instrumentation.
+
+The resulting program can then be traced by running it with the environment
+variable "OCAML_EVENTLOG_ENABLED":
+
+\begin{verbatim}
+ OCAML_EVENTLOG_ENABLED=1 ./program
+\end{verbatim}
+
+During execution, a trace file will be generated in the
+program's current working directory.
+
+\subsubsection*{sss:instr-runtime-build-more}{More build examples}
+
+When using the {\em dune} build system, this compiler invocation can be
+replicated using the {\tt flags} {\tt stanza} when building an executable.
+
+\begin{verbatim}
+ (executable
+ (name program)
+ (flags "-runtime-variant=i"))
+\end{verbatim}
+
+The instrumented runtime can also be used with the OCaml bytecode interpreter.
+This can be done by either using the
+"-runtime-variant=i" flag when linking the program with {\tt ocamlc}, or by running the generated
+bytecode through {\tt ocamlruni}:
+
+\begin{verbatim}
+ ocamlc program.ml -o program.byte
+ OCAML_EVENTLOG_ENABLED=1 ocamlruni program.byte
+\end{verbatim}
+
+See chapter~\ref{c:camlc} and chapter~\ref{c:runtime} for more information about
+{\tt ocamlc} and {\tt ocamlrun}.
+
+\section{s:instr-runtime-read}{Reading traces}
+
+Traces generated by the instrumented runtime can be analyzed with tooling
+available outside of the OCaml distribution.
+
+A complete trace consists of a {\em metadata file} and a {\em trace file}.
+Two simple ways to work with the traces are the {\em eventlog-tools} and
+{\em babeltrace} libraries.
+
+\subsection{ss:instr-runtime-tools}{eventlog-tools}
+{\em eventlog-tools} is a library implementing a parser, as well as a
+a set of tools that allows to perform basic format conversions and analysis.
+
+For more information about {\em eventlog-tools}, refer to the project's
+main page: \href{https://github.com/ocaml-multicore/eventlog-tools}{https://github.com/ocaml-multicore/eventlog-tools}
+
+\subsection{ss:instr-runtime-babeltrace}{babeltrace}
+
+{\em babeltrace} is a C library, as well as a Python binding and set of tools
+that serve as the reference implementation for the {\em Common Trace Format}.
+The {\em babeltrace} command line utility allows for a basic rendering
+of a trace's content, while the high level Python API can be used to
+decode the trace and process them programmatically with libraries
+such as {\em numpy} or {\em Jupyter}.
+
+Unlike {\em eventlog-tools}, which possesses a specific knowledge of
+OCaml's {\em Common Trace Format} schema, it is required to provide
+the OCaml {\em metadata} file to {\em babeltrace}.
+
+The metadata file is available in the OCaml installation.
+Its location can be obtained using the following command:
+
+\begin{verbatim}
+ ocamlc -where
+\end{verbatim}
+
+The {\em eventlog_metadata} file can be found at this path and
+copied in the same directory as the generated trace file.
+However, {\em babeltrace} expects the file to be named
+{\tt metadata} in order to process the trace.
+Thus, it will need to be renamed when copied to the trace's directory.
+
+Here is a naive decoder example, using {\em babeltrace}'s Python
+library, and {\em Python 3.8}:
+
+\begin{verbatim}
+
+import subprocess
+import shutil
+import sys
+import babeltrace as bt
+
+def print_event(ev):
+ print(ev['timestamp'])
+ print(ev['pid'])
+ if ev.name == "entry":
+ print('entry_event')
+ print(ev['phase'])
+ if ev.name == "exit":
+ print('exit_event')
+ print(ev['phase'])
+ if ev.name == "alloc":
+ print(ev['count'])
+ print(ev['bucket'])
+ if ev.name == "counter":
+ print(ev['count'])
+ print(ev['kind'])
+ if ev.name == "flush":
+ print("flush")
+
+def get_ocaml_dir():
+ # Fetching OCaml's installation directory to extract the CTF metadata
+ ocamlc_where = subprocess.run(['ocamlc', '-where'], stdout=subprocess.PIPE)
+ ocaml_dir = ocamlc_where.stdout.decode('utf-8').rstrip('\n')
+ return(ocaml_dir)
+
+def main():
+ trace_dir = sys.argv[1]
+ ocaml_dir = get_ocaml_dir()
+ metadata_path = ocaml_dir + "/eventlog_metadata"
+ # copying the metadata to the trace's directory,
+ # and renaming it to 'metadata'.
+ shutil.copyfile(metadata_path, trace_dir + "/metadata")
+ tr = bt.TraceCollection()
+ tr.add_trace(trace_dir, 'ctf')
+ for event in tr.events:
+ print_event(event)
+
+if __name__ == '__main__':
+ main()
+
+\end{verbatim}
+
+This script expect to receive as an argument the directory containing the
+trace file. It will then copy the {\em CTF} metadata file to the trace's
+directory, and then decode the trace, printing each event in the process.
+
+For more information on {\em babeltrace}, see the website at:
+\href{https://babeltrace.org/}{https://babeltrace.org/}
+
+\section{s:instr-runtime-more}{Controlling instrumentation and limitations}
+
+\subsection{ss:instr-runtime-prefix}{Trace filename}
+
+The default trace filename is {\tt caml-\{PID\}.eventlog}, where {\tt \{PID\}}
+is the process identifier of the traced program.
+
+This filename can also be specified using the
+"OCAML_EVENTLOG_PREFIX" environment variable.
+The given path will be suffixed with {\tt \{.PID\}.eventlog}.
+
+\begin{verbatim}
+ OCAML_EVENTLOG_PREFIX=/tmp/a_prefix OCAML_EVENTLOG_ENABLED=1 ./program
+\end{verbatim}
+
+In this example, the trace will be available at path
+{\tt /tmp/a_prefix.\{PID\}.eventlog}.
+
+Note that this will only affect the prefix of the trace file, there is no
+option to specify the full effective file name.
+This restriction is in place to make room for future improvements to the
+instrumented runtime, where the single trace file per session design
+may be replaced.
+
+For scripting purpose, matching against `\{PID\}`, as well as the
+{\tt .eventlog} file extension should provide enough control over
+the generated files.
+
+Note as well that parent directories in the given path will not be created
+when opening the trace. The runtime assumes the path is
+accessible for creating and writing the trace. The program will
+fail to start if this requirement isn't met.
+
+\subsection{ss:instr-runtime-pause}{Pausing and resuming tracing}
+Mechanisms are available to control event collection at runtime.
+
+"OCAML_EVENTLOG_ENABLED" can be set to the {\tt p} flag in order
+to start the program with event collection paused.
+
+\begin{verbatim}
+ OCAML_EVENTLOG_ENABLED=p ./program
+\end{verbatim}
+
+The program will have to start event collection explicitly.
+Starting and stopping event collection programmatically can be done by calling
+{\tt Gc.eventlog_resume} and {\tt Gc.eventlog_pause}) from within the program.
+Refer to the {\stdmoduleref{Gc}} module documentation for more information.
+
+Running the program provided earlier with "OCAML_EVENTLOG_ENABLED=p"
+will for example yield the following result.
+
+\begin{verbatim}
+$ OCAML_EVENTLOG_ENABLED=p ./program
+$ ocaml-eventlog-report caml-{PID}.eventlog
+==== eventlog/flush
+median flush time: 58ns
+total flush time: 58ns
+flush count: 1
+\end{verbatim}
+
+The resulting trace contains only one event payload, namely a {\em flush} event,
+indicating how much time was spent flushing the trace file to disk.
+
+However, if the program is changed to include a call to
+{\tt Gc.eventlog_resume}, events payloads can be seen again
+in the trace file.
+
+\begin{caml_example*}{verbatim}
+ let () =
+ Gc.eventlog_resume();
+ seq 1_000_000
+ |> Seq.fold_left (fun m i -> SMap.add (s i) i m) SMap.empty
+ |> clear
+ |> ignore
+
+\end{caml_example*}
+
+The resulting trace will contain all events encountered during
+the program's execution:
+
+\begin{verbatim}
+ $ ocaml-eventlog-report caml-{PID}.eventlog
+ [..omitted..]
+ ==== force_minor/alloc_small
+ 100.0K..200.0K: 174
+ 20.0K..30.0K: 1
+ 0..100: 1
+
+ ==== eventlog/flush
+ median flush time: 207.8us
+ total flush time: 938.1us
+ flush count: 5
+\end{verbatim}
+
+\subsection{ss:instr-runtime-limitations}{Limitations}
+
+The instrumented runtime does not support the {\tt fork} system call.
+A child process forked from an instrumented program will not be traced.
+
+The instrumented runtime aims to provide insight into the runtime's execution
+while maintaining a low overhead.
+However, this overhead may become more noticeable depending on how a program
+executes.
+The instrumented runtime currently puts a strong emphasis on
+tracing {\em garbage collection} events. This means that programs
+with heavy garbage collection activity may be more susceptible to
+tracing induced performance penalties.
+
+While providing an accurate estimate of potential performance loss is difficult,
+test on various OCaml programs showed a total running time increase ranging
+from 1\% to 8\%.
+
+For a program with an extended running time where the collection of only a
+small sample of events is required, using the {\em eventlog_resume} and
+{\em eventlog_pause} primitives may help relieve some of the
+tracing induced performance impact.
then loads dynamically these libraries, and resolves references to the
required primitives, before executing the bytecode.
-This facility is currently supported and known to work well under
-Linux, MacOS~X, and Windows. It is supported, but not
-fully tested yet, under FreeBSD, Tru64, Solaris and Irix. It is not
-supported yet under other Unixes.
+This facility is currently available on all platforms supported by
+OCaml except Cygwin 64 bits.
To dynamically link C code with OCaml code, the C code must first be
compiled into a shared library (under Unix) or DLL (under Windows).
manipulate values of that type. An object of type "value" is either:
\begin{itemize}
\item an unboxed integer;
-\item a pointer to a block inside the heap (such as the blocks
-allocated through one of the \verb"caml_alloc_*" functions below);
-\item a pointer to an object outside the heap (e.g., a pointer to a block
-allocated by "malloc", or to a C variable).
- %%% FIXME will change in 4.02.0 (?)
+\item or a pointer to a block inside the heap,
+allocated through one of the \verb"caml_alloc_*" functions described
+in section~\ref{ss:c-block-allocation}.
\end{itemize}
\subsection{ss:c-int}{Integer values}
\subsection{ss:c-outside-head}{Pointers outside the heap}
-Any word-aligned pointer to an address outside the heap can be safely
-cast to and from the type "value". This includes pointers returned by
-"malloc", and pointers to C variables (of size at least one word)
-obtained with the \verb'&' operator.
- %%% FIXME will change in 4.02.0 (?)
-
-Caution: if a pointer returned by "malloc" is cast to the type "value"
-and returned to OCaml, explicit deallocation of the pointer using
-"free" is potentially dangerous, because the pointer may still be
-accessible from the OCaml world. Worse, the memory space deallocated
-by "free" can later be reallocated as part of the OCaml heap; the
-pointer, formerly pointing outside the OCaml heap, now points inside
-the OCaml heap, and this can crash the garbage collector. To avoid
-these problems, it is preferable to wrap the pointer in a OCaml block
-with tag "Abstract_tag" or "Custom_tag".
+In earlier versions of OCaml, it was possible to use
+word-aligned pointers to addresses outside the heap as OCaml values,
+just by casting the pointer to type "value". Starting with OCaml
+4.11, this usage is deprecated and will stop being supported in OCaml 5.00.
+
+A correct way to manipulate pointers to out-of-heap blocks from
+OCaml is to store those pointers in OCaml blocks with tag
+"Abstract_tag" or "Custom_tag", then use the blocks as the OCaml
+values.
+
+Here is an example of encapsulation of out-of-heap pointers of C type
+"ty *" inside "Abstract_tag" blocks. Section~\ref{s:c-intf-example}
+gives a more complete example using "Custom_tag" blocks.
+\begin{verbatim}
+/* Create an OCaml value encapsulating the pointer p */
+static value val_of_typtr(ty * p)
+{
+ value v = caml_alloc(1, Abstract_tag);
+ *((ty **) Data_abstract_val(v)) = p;
+ return v;
+}
+
+/* Extract the pointer encapsulated in the given OCaml value */
+static ty * typtr_of_val(value v)
+{
+ return *((ty **) Data_abstract_val(v));
+}
+\end{verbatim}
+Alternatively, out-of-heap pointers can be treated as ``native''
+integers, that is, boxed 32-bit integers on a 32-bit platform and
+boxed 64-bit integers on a 64-bit platform.
+\begin{verbatim}
+/* Create an OCaml value encapsulating the pointer p */
+static value val_of_typtr(ty * p)
+{
+ return caml_copy_nativeint((intnat) p);
+}
+
+/* Extract the pointer encapsulated in the given OCaml value */
+static ty * typtr_of_val(value v)
+{
+ return (ty *) Nativeint_val(v);
+}
+\end{verbatim}
+For pointers that are at least 2-aligned (the low bit is guaranteed to
+be zero), we have yet another valid representation as an OCaml tagged
+integer.
+\begin{verbatim}
+/* Create an OCaml value encapsulating the pointer p */
+static value val_of_typtr(ty * p)
+{
+ assert (((uintptr_t) p & 1) == 0); /* check correct alignment */
+ return (value) p | 1;
+}
+
+/* Extract the pointer encapsulated in the given OCaml value */
+static ty * typtr_of_val(value v)
+{
+ return (ty *) (v & ~1);
+}
+\end{verbatim}
+
\section{s:c-ocaml-datatype-repr}{Representation of OCaml data types}
\item["-fno-PIC"] Generate position-dependent machine code.
\end{options}
+\paragraph{Options for the PowerPC architecture}
+The PowerPC code generator supports the following additional options:
+
+\begin{options}
+\item["-flarge-toc"] Enables the PowerPC large model allowing the TOC (table of
+contents) to be arbitrarily large. This is the default since 4.11.
+\item["-fsmall-toc"] Enables the PowerPC small model allowing the TOC to be up
+to 64 kbytes per compilation unit. Prior to 4.11 this was the default
+behaviour.
+\end{options}
+
\paragraph{Contextual control of command-line options}
The compiler command line can be modified ``from the outside''
directories, it is recommended to pass "ocamldep" the same "-I" options
that are passed to the compiler.
+\item["-nocwd"]
+Do not add current working directory to the list of include directories.
+
\item["-impl" \var{file}]
Process \var{file} as a ".ml" file.
\item[o] ("space_overhead") The major GC speed setting.
See the Gc module documentation for details.
\item[O] ("max_overhead") The heap compaction trigger setting.
- \item[l] ("stack_limit") The limit (in words) of the stack size.
+ \item[l] ("stack_limit") The limit (in words) of the stack size. This is only
+ relevant to the byte-code runtime, as the native code runtime uses the
+ operating system's stack.
\item[v] ("verbose") What GC messages to print to stderr. This
is a sum of values selected from the following:
\begin{options}
they were typed on standard input. The reading of the file stops at
the first error encountered.
+ \item["#use_output \""\var{command}"\";;"]
+ Execute a command and evaluate its output as if it had been captured
+ to a file and passed to "#use".
+
\item["#mod_use \""\var{file-name}"\";;"]
Similar to "#use" but also wrap the code into a top-level module of the
same name as capitalized file name without extensions, following
Force error messages to show absolute paths for file names.
\notop{\item["-annot"]
-Dump detailed information about the compilation (types, bindings,
-tail-calls, etc). The information for file \var{src}".ml"
-is put into file \var{src}".annot". In case of a type error, dump
-all the information inferred by the type-checker before the error.
-The \var{src}".annot" file can be used with the emacs commands given in
-"emacs/caml-types.el" to display types and other annotations
-interactively.
+Deprecated since OCaml 4.11. Please use "-bin-annot" instead.
}%notop
\item["-args" \var{filename}]
applying the same functor twice to the same argument yields two
incompatible structures.
+\nat{%
+\item["-no-float-const-prop"]
+Deactivates the constant propagation for floating-point operations.
+This option should be given if the program changes the float rounding
+mode during its execution.
+}%nat
+
\item["-noassert"]
Do not compile assertion checks. Note that the special form
"assert false" is always compiled because it is typed specially.
shown below:
\begin{unix} This is material specific to the Unix family of operating
-systems, including Linux and \hbox{MacOS~X}.
+systems, including Linux and macOS.
\end{unix}
\begin{windows} This is material specific to Microsoft Windows
\section*{availability}{Availability}
\begin{latexonly}
-The complete OCaml distribution can be accessed via the Web
-sites \url{http://www.ocaml.org/} and \url{http://caml.inria.fr/}.
-The former Web site contains a lot of additional information on OCaml.
+The complete OCaml distribution can be accessed via the website
+\url{https://ocaml.org/}. This site contains a lot of additional
+information on OCaml.
\end{latexonly}
\begin{htmlonly}
The complete OCaml distribution can be accessed via the
-\href{http://www.ocaml.org/}{community Caml Web site} and the
-\href{http://caml.inria.fr/}{older Caml Web site}.
-The \href{http://www.ocaml.org/}{community Caml Web site}
-contains a lot of additional information on OCaml.
+\href{https://ocaml.org/}{ocaml.org website}.
+This site contains a lot of additional information on OCaml.
\end{htmlonly}
\section{s:stdlib-module}{Module {\tt Stdlib}: the initially opened module}
\begin{links}
\item \ahref{libref/Stdlib.html}{Module \texttt{Stdlib}: the initially opened module}
-\item \ahref{libref/Pervasives.html}{Module \texttt{Pervasives}: deprecated alias for Stdlib}
+\item Module \texttt{Pervasives}: deprecated alias for Stdlib
\end{links}
\else
{
\newstyle{div.ocaml .pre}{
white-space: pre;
- font-family:mono;
+ font-family: monospace;
}
\def\versionspecific#1{\begin{quote}\textsf{#1:}\quad}
\def\unix{\versionspecific{Unix}}
\def\endunix{\end{quote}}
-\def\macos{\versionspecific{MacOS~9}}
-\def\endmacos{\end{quote}}
\def\windows{\versionspecific{Windows}}
\def\endwindows{\end{quote}}
\def\unix{\versionspecific{Unix}}
\def\endunix{\end{description}}
-%\def\macos{\versionspecific{MacOS 9}}
-%\def\endmacos{\end{description}}
\def\windows{\versionspecific{Windows}}
\def\endwindows{\end{description}}
\def\unix{\versionspecific{Unix}}
\def\endunix{\end{quote}}
-\def\macos{\versionspecific{MacOS}}
-\def\endmacos{\end{quote}}
\def\windows{\versionspecific{Windows}}
\def\endwindows{\end{quote}}
| 'try' expr 'with' pattern-matching
| 'let' ['rec'] let-binding { 'and' let-binding } 'in' expr
| "let" "exception" constr-decl "in" expr
- | 'new' class-path
- | 'object' class-body 'end'
- | expr '#' method-name
- | inst-var-name
- | inst-var-name '<-' expr
+ | 'let' 'module' module-name { '(' module-name ':' module-type ')' }
+ [ ':' module-type ] \\ '=' module-expr 'in' expr
| '(' expr ':>' typexpr ')'
| '(' expr ':' typexpr ':>' typexpr ')'
- | '{<' [ inst-var-name ['=' expr] { ';' inst-var-name ['=' expr] } [';'] ] '>}'
| 'assert' expr
| 'lazy' expr
- | 'let' 'module' module-name { '(' module-name ':' module-type ')' }
- [ ':' module-type ] \\ '=' module-expr 'in' expr
- | "let" "open" module-path "in" expr
- | module-path '.(' expr ')'
- | module-path '.[' expr ']'
- | module-path '.[|' expr '|]'
- | module-path '.{' expr '}'
- | module-path '.{<' expr '>}'
+ | local-open
+ | object-expr
;
%BEGIN LATEX
\end{syntax} \begin{syntax}
| '?' '(' label-name [':' typexpr] ['=' expr] ')'
| '?' label-name ':' pattern
| '?' label-name ':' '(' pattern [':' typexpr] ['=' expr] ')'
+;
+local-open:
+ | "let" "open" module-path "in" expr
+ | module-path '.(' expr ')'
+ | module-path '.[' expr ']'
+ | module-path '.[|' expr '|]'
+ | module-path '.{' expr '}'
+ | module-path '.{<' expr '>}'
+;
+object-expr:
+ | 'new' class-path
+ | 'object' class-body 'end'
+ | expr '#' method-name
+ | inst-var-name
+ | inst-var-name '<-' expr
+ | '{<' [ inst-var-name ['=' expr] { ';' inst-var-name ['=' expr] } [';'] ] '>}'
\end{syntax}
See also the following language extensions:
\hyperref[s:first-class-modules]{first-class modules},
\begin{verbatim}
let[@foo] x = 2 in x + 1 === (let x = 2 [@@foo] in x + 1)
-begin[@foo][@bar x] ... end === (begin ... end)[@foo][@@bar x]
+begin[@foo][@bar x] ... end === (begin ... end)[@foo][@bar x]
module[@foo] M = ... === module M = ... [@@foo]
type[@foo] t = T === type t = T [@@foo]
method[@foo] m = ... === method m = ... [@@foo]
\begin{verbatim}
let[@foo] x = 2 and y = 3 in x + y === (let x = 2 [@@foo] and y = 3 in x + y)
let[@foo] x = 2
-and[@bar] y = 3 in x + y === (let x = 2 [@@foo] and y = 3 [@bar] in x + y)
+and[@bar] y = 3 in x + y === (let x = 2 [@@foo] and y = 3 [@@bar] in x + y)
\end{verbatim}
fun%foo[@bar] x -> x + 1 === [%foo (fun x -> x + 1)[@bar ] ];
\end{verbatim}
-Quoted strings "{|...|}" are particularly interesting for payloads
-that embed foreign syntax fragments. Those fragments can be interpreted
+Furthermore, quoted strings "{|...|}" can be combined with extension nodes
+to embed foreign syntax fragments. Those fragments can be interpreted
by a preprocessor and turned into OCaml code without requiring escaping
-quotes. For instance, you can use "[%sql {|...|}]" to
+quotes. A syntax shortcut is available for them:
+
+\begin{verbatim}
+{%%foo|...|} === [%%foo{|...|}]
+let x = {%foo|...|} === let x = [%foo{|...|}]
+let y = {%foo bar|...|bar} === let y = [%foo{bar|...|bar}]
+\end{verbatim}
+
+For instance, you can use "{%sql|...|}" to
represent arbitrary SQL statements -- assuming you have a ppx-rewriter
that recognizes the "%sql" extension.
| polymorphic-variant-type
| '<' ['..'] '>'
| '<' method-type { ';' method-type } [';' || ';' '..'] '>'
- | '#' class-path
+ | '#' classtype-path
| typexpr '#' class-path
| '(' typexpr { ',' typexpr } ')' '#' class-path
;
\subsubsection*{sss:typexpr-sharp-types}{\#-types}
-The type @'#' class-path@ is a special kind of abbreviation. This
+The type @'#' classtype-path@ is a special kind of abbreviation. This
abbreviation unifies with the type of any object belonging to a subclass
-of class @class-path@.
+of the class type @classtype-path@.
%
It is handled in a special way as it usually hides a type variable (an
ellipsis, representing the methods that may be added in a subclass).
In particular, it vanishes when the ellipsis gets instantiated.
%
-Each type expression @'#' class-path@ defines a new type variable, so
-type @'#' class-path '->' '#' class-path@ is usually not the same as
-type @('#' class-path 'as' "'" ident) '->' "'" ident@.
+Each type expression @'#' classtype-path@ defines a new type variable, so
+type @'#' classtype-path '->' '#' classtype-path@ is usually not the same as
+type @('#' classtype-path 'as' "'" ident) '->' "'" ident@.
%
Use of \#-types to abbreviate polymorphic variant types is deprecated.
to mark the end of a top-level expression unambiguously even when
there are syntax errors.
Here is a
-sample standalone program to print Fibonacci numbers:
+sample standalone program to print the greatest common divisor
+(gcd) of two numbers:
\begin{verbatim}
-(* File fib.ml *)
-let rec fib n =
- if n < 2 then 1 else fib (n-1) + fib (n-2);;
+(* File gcd.ml *)
+let rec gcd a b =
+ if b = 0 then a
+ else gcd b (a mod b);;
+
let main () =
- let arg = int_of_string Sys.argv.(1) in
- print_int (fib arg);
- print_newline ();
+ let a = int_of_string Sys.argv.(1) in
+ let b = int_of_string Sys.argv.(2) in
+ Printf.printf "%d\n" (gcd a b);
exit 0;;
main ();;
\end{verbatim}
The program above is compiled and executed with the following shell
commands:
\begin{verbatim}
-$ ocamlc -o fib fib.ml
-$ ./fib 10
-89
-$ ./fib 20
-10946
+$ ocamlc -o gcd gcd.ml
+$ ./gcd 6 9
+3
+$ ./fib 7 11
+1
\end{verbatim}
More complex standalone OCaml programs are typically composed of
then None
else begin match attr.attr_payload with
| PStr [{pstr_desc= Pstr_eval
- ({ pexp_desc = Pexp_constant Pconst_string (s,_) },_) } ] ->
+ ({ pexp_desc = Pexp_constant Pconst_string (s,_,_) },_) } ] ->
Some s
| _ -> print_error (Wrong_attribute_payload attr.attr_loc);
Some "" (* triggers an error *)
}
let print ppf { module_path; location; original_ident; } =
- Format.fprintf ppf "@[<hov 1>(\
- @[<hov 1>(module_path@ %a)@]@ \
- @[<hov 1>(location@ %a)@]@ \
- @[<hov 1>(original_ident@ %a)@]\
- )@]"
- Path.print module_path
- Debuginfo.print_compact location
- Ident.print original_ident
+ let printf fmt = Format.fprintf ppf fmt in
+ printf "@[<hov 1>(";
+ printf "@[<hov 1>(module_path@ %a)@]@ "
+ Path.print module_path;
+ if !Clflags.locations then
+ printf "@[<hov 1>(location@ %a)@]@ "
+ Debuginfo.print_compact location;
+ printf "@[<hov 1>(original_ident@ %a)@]"
+ Ident.print original_ident;
+ printf ")@]"
let create ~module_path ~location ~original_ident =
{ module_path;
| Pandint | Porint | Pxorint
| Plslint | Plsrint | Pasrint
| Pintcomp of integer_comparison
+ | Pcompare_ints | Pcompare_floats | Pcompare_bints of boxed_integer
| Poffsetint of int
| Poffsetref of int
(* Float operations *)
| Pandint | Porint | Pxorint
| Plslint | Plsrint | Pasrint
| Pintcomp of integer_comparison
+ | Pcompare_ints | Pcompare_floats | Pcompare_bints of boxed_integer
| Poffsetint of int
| Poffsetref of int
(* Float operations *)
| Uunreachable ->
Uunreachable
-(* Perform an inline expansion *)
+type env = {
+ backend : (module Backend_intf.S);
+ cenv : ulambda V.Map.t;
+ fenv : value_approximation V.Map.t;
+ mutable_vars : V.Set.t;
+}
+
+(* Perform an inline expansion:
+
+ If [f p = body], substitute [f a] by [let p = a in body].
-let is_simple_argument = function
- | Uvar _ | Uconst _ -> true
+ Under certain conditions, further simplifications are possible (we use the
+ terminology of [Semantics_of_primitives], applied to terms of the Clambda
+ language):
+
+ - [f a] is equivalent to [body[a/p]] if [a] has no effects and no coeffects.
+ However, we only want to do this rewriting if [body[a/p]] does not increase
+ the size of [body]. Since this is hard to decide in general, as an
+ approximation, only consider the case when [a] is an immutable variable or
+ a constant.
+
+ - [f a] is equivalent to [body] if [p] does not occur in [body] and [a] has
+ only generative effects.
+
+ - In general [f a] is equivalent to [a; body] if [p] does not occur in
+ [body].
+*)
+
+(* Approximates "no effects and no coeffects" *)
+let is_substituable ~mutable_vars = function
+ | Uvar v -> not (V.Set.mem v mutable_vars)
+ | Uconst _ -> true
| _ -> false
-let no_effects = function
+(* Approximates "only generative effects" *)
+let is_erasable = function
| Uclosure _ -> true
| u -> is_pure u
-let rec bind_params_rec loc fpc subst params args body =
- match (params, args) with
- ([], []) -> substitute loc fpc subst (Some Int.Map.empty) body
- | (p1 :: pl, a1 :: al) ->
- if is_simple_argument a1 then
- bind_params_rec loc fpc (V.Map.add (VP.var p1) a1 subst)
- pl al body
- else begin
- let p1' = VP.rename p1 in
- let u1, u2 =
- match VP.name p1, a1 with
- | "*opt*", Uprim(P.Pmakeblock(0, Immutable, kind), [a], dbg) ->
- a, Uprim(P.Pmakeblock(0, Immutable, kind),
- [Uvar (VP.var p1')], dbg)
- | _ ->
- a1, Uvar (VP.var p1')
- in
- let body' =
- bind_params_rec loc fpc (V.Map.add (VP.var p1) u2 subst)
- pl al body in
- if occurs_var (VP.var p1) body then
- Ulet(Immutable, Pgenval, p1', u1, body')
- else if no_effects a1 then body'
- else Usequence(a1, body')
- end
- | (_, _) -> assert false
-
-let bind_params loc fpc params args body =
+let bind_params { backend; mutable_vars; _ } loc fpc params args body =
+ let rec aux subst pl al body =
+ match (pl, al) with
+ ([], []) -> substitute (Debuginfo.from_location loc) (backend, fpc)
+ subst (Some Int.Map.empty) body
+ | (p1 :: pl, a1 :: al) ->
+ if is_substituable ~mutable_vars a1 then
+ aux (V.Map.add (VP.var p1) a1 subst) pl al body
+ else begin
+ let p1' = VP.rename p1 in
+ let u1, u2 =
+ match VP.name p1, a1 with
+ | "*opt*", Uprim(P.Pmakeblock(0, Immutable, kind), [a], dbg) ->
+ a, Uprim(P.Pmakeblock(0, Immutable, kind),
+ [Uvar (VP.var p1')], dbg)
+ | _ ->
+ a1, Uvar (VP.var p1')
+ in
+ let body' = aux (V.Map.add (VP.var p1) u2 subst) pl al body in
+ if occurs_var (VP.var p1) body then
+ Ulet(Immutable, Pgenval, p1', u1, body')
+ else if is_erasable a1 then body'
+ else Usequence(a1, body')
+ end
+ | (_, _) -> assert false
+ in
(* Reverse parameters and arguments to preserve right-to-left
evaluation order (PR#2910). *)
- bind_params_rec loc fpc V.Map.empty (List.rev params) (List.rev args) body
+ aux V.Map.empty (List.rev params) (List.rev args) body
(* Check if a lambda term is ``pure'',
that is without side-effects *and* not containing function definitions *)
let warning_if_forced_inline ~loc ~attribute warning =
if attribute = Always_inline then
- Location.prerr_warning loc
+ Location.prerr_warning (Debuginfo.Scoped_location.to_location loc)
(Warnings.Inlining_impossible warning)
(* Generate a direct application *)
-let direct_apply ~backend fundesc ufunct uargs ~loc ~attribute =
+let direct_apply env fundesc ufunct uargs ~loc ~attribute =
let app_args =
if fundesc.fun_closed then uargs else uargs @ [ufunct] in
let app =
"Function information unavailable";
Udirect_apply(fundesc.fun_label, app_args, dbg)
| Some(params, body), _ ->
- bind_params loc (backend, fundesc.fun_float_const_prop) params app_args
+ bind_params env loc fundesc.fun_float_const_prop params app_args
body
in
(* If ufunct can contain side-effects or function definitions,
exception NotClosed
-type env = {
- backend : (module Backend_intf.S);
- cenv : ulambda V.Map.t;
- fenv : value_approximation V.Map.t;
-}
-
let close_approx_var { fenv; cenv } id =
let approx = try V.Map.find id fenv with Not_found -> Value_unknown in
match approx with
let close_var env id =
let (ulam, _app) = close_approx_var env id in ulam
-let rec close ({ backend; fenv; cenv } as env) lam =
+let rec close ({ backend; fenv; cenv ; mutable_vars } as env) lam =
let module B = (val backend : Backend_intf.S) in
match lam with
| Lvar id ->
str (Uconst_float_array (List.map float_of_string sl))
| Const_immstring s ->
str (Uconst_string s)
- | Const_base (Const_string (s, _)) ->
+ | Const_base (Const_string (s, _, _)) ->
(* Strings (even literal ones) must be assumed to be mutable...
except when OCaml has been configured with
-safe-string. Passing -safe-string at compilation
[Uprim(P.Pmakeblock _, uargs, _)])
when List.length uargs = - fundesc.fun_arity ->
let app =
- direct_apply ~backend ~loc ~attribute fundesc ufunct uargs in
+ direct_apply env ~loc ~attribute fundesc ufunct uargs in
(app, strengthen_approx app approx_res)
| ((ufunct, Value_closure(fundesc, approx_res)), uargs)
when nargs = fundesc.fun_arity ->
let app =
- direct_apply ~backend ~loc ~attribute fundesc ufunct uargs in
+ direct_apply env ~loc ~attribute fundesc ufunct uargs in
(app, strengthen_approx app approx_res)
| ((ufunct, (Value_closure(fundesc, _) as fapprox)), uargs)
in
let funct_var = V.create_local "funct" in
let fenv = V.Map.add funct_var fapprox fenv in
- let (new_fun, approx) = close { backend; fenv; cenv }
+ let (new_fun, approx) = close { backend; fenv; cenv; mutable_vars }
(Lfunction{
kind = Curried;
return = Pgenval;
let dbg = Debuginfo.from_location loc in
warning_if_forced_inline ~loc ~attribute "Over-application";
let body =
- Ugeneric_apply(direct_apply ~backend ~loc ~attribute
+ Ugeneric_apply(direct_apply env ~loc ~attribute
fundesc ufunct first_args,
rem_args, dbg)
in
let (ulam, alam) = close_named env id lam in
begin match (str, alam) with
(Variable, _) ->
+ let env = {env with mutable_vars = V.Set.add id env.mutable_vars} in
let (ubody, abody) = close env body in
(Ulet(Mutable, kind, VP.create id, ulam, ubody), abody)
| (_, Value_const _)
when str = Alias || is_pure ulam ->
- close { backend; fenv = (V.Map.add id alam fenv); cenv } body
+ close { backend; fenv = (V.Map.add id alam fenv); cenv; mutable_vars }
+ body
| (_, _) ->
let (ubody, abody) =
- close { backend; fenv = (V.Map.add id alam fenv); cenv } body
+ close
+ { backend; fenv = (V.Map.add id alam fenv); cenv; mutable_vars }
+ body
in
(Ulet(Immutable, kind, VP.create id, ulam, ubody), abody)
end
List.fold_right
(fun (id, _pos, approx) fenv -> V.Map.add id approx fenv)
infos fenv in
- let (ubody, approx) = close { backend; fenv = fenv_body; cenv } body in
+ let (ubody, approx) =
+ close { backend; fenv = fenv_body; cenv; mutable_vars } body in
let sb =
List.fold_right
(fun (id, pos, _approx) sb ->
V.Map.add id (Uoffset(Uvar clos_ident, pos)) sb)
infos V.Map.empty in
(Ulet(Immutable, Pgenval, VP.create clos_ident, clos,
- substitute Location.none (backend, !Clflags.float_const_prop) sb
+ substitute Debuginfo.none (backend, !Clflags.float_const_prop) sb
None ubody),
approx)
end else begin
let (ulam, approx) = close_named env id lam in
((VP.create id, ulam) :: udefs, V.Map.add id approx fenv_body) in
let (udefs, fenv_body) = clos_defs defs in
- let (ubody, approx) = close { backend; fenv = fenv_body; cenv } body in
+ let (ubody, approx) =
+ close { backend; fenv = fenv_body; cenv; mutable_vars } body in
(Uletrec(udefs, ubody), approx)
end
(* Compile-time constants *)
(* Build a shared closure for a set of mutually recursive functions *)
-and close_functions { backend; fenv; cenv } fun_defs =
+and close_functions { backend; fenv; cenv; mutable_vars } fun_defs =
let fun_defs =
List.flatten
(List.map
V.Map.add id (Uoffset(Uvar env_param, pos - env_pos)) env)
uncurried_defs clos_offsets cenv_fv in
let (ubody, approx) =
- close { backend; fenv = fenv_rec; cenv = cenv_body } body
+ close { backend; fenv = fenv_rec; cenv = cenv_body; mutable_vars } body
in
if !useless_env && occurs_var env_param ubody then raise NotClosed;
let fun_params =
in
let magic_scale_constant = 8. in
int_of_float (inline_threshold *. magic_scale_constant) + n
- | Always_inline -> max_int
+ | Always_inline | Hint_inline -> max_int
| Never_inline -> min_int
| Unroll _ -> assert false
in
with offsets and approximations. *)
let (clos, infos) = List.split clos_info_list in
let fv = if !useless_env then [] else fv in
- (Uclosure(clos, List.map (close_var { backend; fenv; cenv }) fv), infos)
+ (Uclosure(clos,
+ List.map (close_var { backend; fenv; cenv; mutable_vars }) fv),
+ infos)
(* Same, for one non-recursive function *)
global_approx := Array.init size (fun i -> Value_global_field (id, i));
Compilenv.set_global_approx(Value_tuple !global_approx);
let (ulam, _approx) =
- close { backend; fenv = V.Map.empty; cenv = V.Map.empty } lam
+ close { backend; fenv = V.Map.empty;
+ cenv = V.Map.empty; mutable_vars = V.Set.empty } lam
in
let opaque =
!Clflags.opaque
| Plsrint -> Plsrint
| Pasrint -> Pasrint
| Pintcomp comp -> Pintcomp comp
+ | Pcompare_ints -> Pcompare_ints
+ | Pcompare_floats -> Pcompare_floats
+ | Pcompare_bints bi -> Pcompare_bints bi
| Poffsetint offset -> Poffsetint offset
| Poffsetref offset -> Poffsetref offset
| Pintoffloat -> Pintoffloat
~root_symbol:(Compilenv.current_unit_symbol ())
in
let sets_of_closures =
- Set_of_closures_id.Map.filter_map
- function_declarations_map
- ~f:(fun key (fun_decls : Simple_value_approx.function_declarations) ->
+ function_declarations_map |> Set_of_closures_id.Map.filter_map
+ (fun key (fun_decls : Simple_value_approx.function_declarations) ->
if Set_of_closures_id.Set.mem key relevant_set_of_closures then
Some fun_decls
else if begin
match const with
| Const_base (Const_int c) -> (Const (Int c), Names.const_int)
| Const_base (Const_char c) -> (Const (Char c), Names.const_char)
- | Const_base (Const_string (s, _)) ->
+ | Const_base (Const_string (s, _, _)) ->
let const, name =
if Config.safe_string then
(Flambda.Allocated_const (Immutable_string s),
body : Lambda.lambda;
free_idents_of_body : Ident.Set.t;
attr : Lambda.function_attribute;
- loc : Location.t;
+ loc : Lambda.scoped_location
}
let create ~let_rec_ident ~closure_bound_var ~kind ~params ~body
-> params:Ident.t list
-> body:Lambda.lambda
-> attr:Lambda.function_attribute
- -> loc:Location.t
+ -> loc:Lambda.scoped_location
-> t
val let_rec_ident : t -> Ident.t
val specialise : t -> Lambda.specialise_attribute
val is_a_functor : t -> bool
val stub : t -> bool
- val loc : t -> Location.t
+ val loc : t -> Lambda.scoped_location
(* Like [all_free_idents], but for just one function. *)
val free_idents : t -> Ident.Set.t
match inline with
| Always_inline -> fprintf ppf "<always>"
| Never_inline -> fprintf ppf "<never>"
+ | Hint_inline -> fprintf ppf "<hint>"
| Unroll i -> fprintf ppf "<unroll %i>" i
| Default_inline -> ()
in
in
let inline =
match f.inline with
- | Always_inline -> " *inline*"
+ | Always_inline | Hint_inline -> " *inline*"
| Never_inline -> " *never_inline*"
| Unroll _ -> " *unroll*"
| Default_inline -> ""
: function_declaration =
begin match stub, inline with
| true, (Never_inline | Default_inline)
- | false, (Never_inline | Default_inline | Always_inline | Unroll _) -> ()
- | true, (Always_inline | Unroll _) ->
+ | false, (Never_inline | Default_inline
+ | Always_inline | Hint_inline | Unroll _) -> ()
+ | true, (Always_inline | Hint_inline | Unroll _) ->
Misc.fatal_errorf
- "Stubs may not be annotated as [Always_inline] or [Unroll]: %a"
+ "Stubs may not be annotated as [Always_inline], \
+ [Hint_inline] or [Unroll]: %a"
print body
end;
begin match stub, specialise with
(* Check that there aren't any unused "always inline" attributes. *)
Flambda_iterators.iter_apply_on_program flam ~f:(fun apply ->
match apply.inline with
- | Default_inline | Never_inline -> ()
+ | Default_inline | Never_inline | Hint_inline -> ()
| Always_inline ->
(* CR-someday mshinwell: consider a different error message if
this triggers as a result of the propagation of a user's
| Unroll _ ->
Location.prerr_warning (Debuginfo.to_location apply.dbg)
(Warnings.Inlining_impossible
- "[@unroll] attribute was not used on this function \
+ "[@unrolled] attribute was not used on this function \
application (the optimizer did not know what function \
was being applied)"));
if !Clflags.dump_flambda
on partial applications")
| Unroll _ ->
Location.prerr_warning (Debuginfo.to_location dbg)
- (Warnings.Inlining_impossible "[@unroll] attributes may not be used \
+ (Warnings.Inlining_impossible "[@unrolled] attributes may not be used \
on partial applications")
- | Default_inline -> ()
+ | Hint_inline | Default_inline -> ()
end;
begin match (specialise_requested : Lambda.specialise_attribute) with
| Always_specialise | Never_specialise ->
{ t with inlined_debuginfo = dbg }
let add_inlined_debuginfo t ~dbg =
- Debuginfo.concat t.inlined_debuginfo dbg
+ Debuginfo.inline t.inlined_debuginfo dbg
end
let initial_inlining_threshold ~round : Inlining_cost.Threshold.t =
match fun_decl.inline with
| Default_inline -> can_inline_non_rec_function fun_decl
| Unroll factor -> factor > 0
- | Always_inline -> true
+ | Always_inline | Hint_inline -> true
| Never_inline -> false
end
end
set_of_closures.free_vars
in
let specialised_args =
- Variable.Map.filter_map set_of_closures.specialised_args
- ~f:(fun param (spec_to : Flambda.specialised_to) ->
+ set_of_closures.specialised_args |> Variable.Map.filter_map
+ (fun param (spec_to : Flambda.specialised_to) ->
let keep =
match only_for_function_decl with
| None -> true
(* Merge call site annotation and function annotation.
The call site annotation takes precedence *)
match (inline_requested : Lambda.inline_attribute) with
- | Always_inline | Never_inline | Unroll _ -> inline_requested
+ | Always_inline | Hint_inline | Never_inline | Unroll _ ->
+ inline_requested
| Default_inline -> function_body.inline
in
match inline_annotation with
- | Always_inline -> false, true, false, env
+ | Always_inline | Hint_inline -> false, true, false, env
| Never_inline -> false, false, true, env
| Default_inline -> false, false, false, env
| Unroll count ->
| Some _ -> Default_inline
| None -> inline_requested
end
- | Always_inline | Default_inline | Never_inline ->
+ | Always_inline | Hint_inline | Default_inline | Never_inline ->
inline_requested
in
let original =
let is_a_functor = if b.is_a_functor then " *functor*" else "" in
let inline =
match b.inline with
- | Always_inline -> " *inline*"
+ | Always_inline | Hint_inline -> " *inline*"
| Never_inline -> " *never_inline*"
| Unroll _ -> " *unroll*"
| Default_inline -> ""
| Pxorbint kind when equal_kind kind I.kind -> eval I.logxor
| Pbintcomp (kind, c) when equal_kind kind I.kind ->
S.const_integer_comparison_expr expr c n1 n2
+ | Pcompare_bints kind when equal_kind kind I.kind ->
+ S.const_int_expr expr (I.compare n1 n2)
| _ -> expr, A.value_unknown Other, C.Benefit.zero
let simplify_binop_int (p : Clambda_primitives.primitive)
let a = f 1
let b = f 1
let c = a, a
- let d = a, a
+ let d = b, b
If [Share_constants] is run before [f] is completely inlined (assuming
[f] always generates the same result; effects of [f] aren't in fact
| Plsrint when shift_precond -> S.const_int_expr expr (x lsr y)
| Pasrint when shift_precond -> S.const_int_expr expr (x asr y)
| Pintcomp cmp -> S.const_integer_comparison_expr expr cmp x y
+ | Pcompare_ints -> S.const_int_expr expr (compare x y)
| Pisout -> S.const_bool_expr expr (y > x || y < 0)
| _ -> expr, A.value_unknown Other, C.Benefit.zero
end
| [Value_char x; Value_char y] ->
begin match p with
| Pintcomp cmp -> S.const_integer_comparison_expr expr cmp x y
+ | Pcompare_ints -> S.const_int_expr expr (Char.compare x y)
| _ -> expr, A.value_unknown Other, C.Benefit.zero
end
| [Value_constptr x] ->
| Pmulfloat -> S.const_float_expr expr (n1 *. n2)
| Pdivfloat -> S.const_float_expr expr (n1 /. n2)
| Pfloatcomp c -> S.const_float_comparison_expr expr c n1 n2
+ | Pcompare_floats -> S.const_int_expr expr (Float.compare n1 n2)
| _ -> expr, A.value_unknown Other, C.Benefit.zero
end
| [A.Value_boxed_int(A.Nativeint, n)] ->
(b) it is never assigned to (using [Uassign]).
*)
type var_info =
- { used : V.Set.t;
- linear : V.Set.t;
+ { used_let_bound_vars : V.Set.t;
+ linear_let_bound_vars : V.Set.t;
assigned : V.Set.t;
closure_environment : V.Set.t;
let_bound_vars_that_can_be_moved : V.Set.t;
(* closed function, no environment *)
None
+type var_uses =
+ | Zero
+ | One
+ | More_than_one
+ | Assigned
+
+type var =
+ { definition_depth : int;
+ uses : var_uses; }
+
+let incr_uses { definition_depth; uses } depth =
+ assert (definition_depth <= depth);
+ let uses =
+ match uses with
+ | Zero ->
+ if definition_depth < depth then More_than_one
+ else One
+ | One -> More_than_one
+ | More_than_one -> More_than_one
+ | Assigned -> Assigned
+ in
+ { definition_depth; uses }
+
+let assign_uses r = { r with uses = Assigned }
+
+let zero definition_depth = { definition_depth; uses = Zero }
+
+let add_definition t var depth =
+ V.Tbl.add t var (zero depth)
+
+let add_use t var depth =
+ match V.Tbl.find t var with
+ | info -> V.Tbl.replace t var (incr_uses info depth)
+ | exception Not_found -> () (* Variable is not let-bound *)
+
+let add_assignment t var =
+ match V.Tbl.find t var with
+ | info -> V.Tbl.replace t var (assign_uses info)
+ | exception Not_found ->
+ Misc.fatal_errorf
+ "make_var_info: Assigned variable %a not let-bound"
+ V.print var
+
let make_var_info (clam : Clambda.ulambda) : var_info =
- let t : int V.Tbl.t = V.Tbl.create 42 in
- let assigned_vars = ref V.Set.empty in
+ let t : var V.Tbl.t = V.Tbl.create 42 in
let environment_vars = ref V.Set.empty in
- let rec loop : Clambda.ulambda -> unit = function
+ let rec loop ~depth : Clambda.ulambda -> unit = function
(* No underscores in the pattern match, to reduce the chance of failing
to traverse some subexpression. *)
- | Uvar var ->
- begin match V.Tbl.find t var with
- | n -> V.Tbl.replace t var (n + 1)
- | exception Not_found -> V.Tbl.add t var 1
- end
+ | Uvar var -> add_use t var depth
| Uconst const ->
(* The only variables that might occur in [const] are those in constant
closures---and those are all bound by such closures. It follows that
[const] cannot contain any variables that are bound in the current
scope, so we do not need to count them here. (The function bodies
of the closures will be traversed when this function is called from
- [Cmmgen.transl_function].) *)
+ [Flambda_to_clambda.to_clambda_closed_set_of_closures].) *)
ignore_uconstant const
| Udirect_apply (label, args, dbg) ->
ignore_function_label label;
- List.iter loop args;
+ List.iter (loop ~depth) args;
ignore_debuginfo dbg
| Ugeneric_apply (func, args, dbg) ->
- loop func;
- List.iter loop args;
+ loop ~depth func;
+ List.iter (loop ~depth) args;
ignore_debuginfo dbg
| Uclosure (functions, captured_variables) ->
- List.iter loop captured_variables;
+ List.iter (loop ~depth) captured_variables;
List.iter (fun (
{ Clambda. label; arity; params; return; body; dbg; env; } as clos) ->
(match closure_environment_var clos with
ignore_int arity;
ignore_params_with_value_kind params;
ignore_value_kind return;
- loop body;
+ loop ~depth:(depth + 1) body;
ignore_debuginfo dbg;
ignore_var_option env)
functions
| Uoffset (expr, offset) ->
- loop expr;
+ loop ~depth expr;
ignore_int offset
- | Ulet (_let_kind, _value_kind, _var, def, body) ->
- loop def;
- loop body
+ | Ulet (_let_kind, _value_kind, var, def, body) ->
+ add_definition t (VP.var var) depth;
+ loop ~depth def;
+ loop ~depth body
| Uphantom_let (var, defining_expr_opt, body) ->
ignore_var_with_provenance var;
ignore_uphantom_defining_expr_option defining_expr_opt;
- loop body
+ loop ~depth body
| Uletrec (defs, body) ->
List.iter (fun (var, def) ->
ignore_var_with_provenance var;
- loop def)
+ loop ~depth def)
defs;
- loop body
+ loop ~depth body
| Uprim (prim, args, dbg) ->
ignore_primitive prim;
- List.iter loop args;
+ List.iter (loop ~depth) args;
ignore_debuginfo dbg
| Uswitch (cond, { us_index_consts; us_actions_consts;
us_index_blocks; us_actions_blocks }, dbg) ->
- loop cond;
+ loop ~depth cond;
ignore_int_array us_index_consts;
- Array.iter loop us_actions_consts;
+ Array.iter (loop ~depth) us_actions_consts;
ignore_int_array us_index_blocks;
- Array.iter loop us_actions_blocks;
+ Array.iter (loop ~depth) us_actions_blocks;
ignore_debuginfo dbg
| Ustringswitch (cond, branches, default) ->
- loop cond;
+ loop ~depth cond;
List.iter (fun (str, branch) ->
ignore_string str;
- loop branch)
+ loop ~depth branch)
branches;
- Option.iter loop default
+ Option.iter (loop ~depth) default
| Ustaticfail (static_exn, args) ->
ignore_int static_exn;
- List.iter loop args
+ List.iter (loop ~depth) args
| Ucatch (static_exn, vars, body, handler) ->
ignore_int static_exn;
ignore_params_with_value_kind vars;
- loop body;
- loop handler
+ loop ~depth body;
+ loop ~depth handler
| Utrywith (body, var, handler) ->
- loop body;
+ loop ~depth body;
ignore_var_with_provenance var;
- loop handler
+ loop ~depth handler
| Uifthenelse (cond, ifso, ifnot) ->
- loop cond;
- loop ifso;
- loop ifnot
+ loop ~depth cond;
+ loop ~depth ifso;
+ loop ~depth ifnot
| Usequence (e1, e2) ->
- loop e1;
- loop e2
+ loop ~depth e1;
+ loop ~depth e2
| Uwhile (cond, body) ->
- loop cond;
- loop body
+ loop ~depth:(depth + 1) cond;
+ loop ~depth:(depth + 1) body
| Ufor (var, low, high, direction_flag, body) ->
ignore_var_with_provenance var;
- loop low;
- loop high;
+ loop ~depth low;
+ loop ~depth high;
ignore_direction_flag direction_flag;
- loop body
+ loop ~depth:(depth + 1) body
| Uassign (var, expr) ->
- assigned_vars := V.Set.add var !assigned_vars;
- loop expr
+ add_assignment t var;
+ loop ~depth expr
| Usend (meth_kind, e1, e2, args, dbg) ->
ignore_meth_kind meth_kind;
- loop e1;
- loop e2;
- List.iter loop args;
+ loop ~depth e1;
+ loop ~depth e2;
+ List.iter (loop ~depth) args;
ignore_debuginfo dbg
| Uunreachable ->
()
in
- loop clam;
- let linear =
- V.Tbl.fold (fun var n acc ->
- assert (n >= 1);
- if n = 1 && not (V.Set.mem var !assigned_vars)
- then V.Set.add var acc
- else acc)
- t V.Set.empty
- in
- let assigned = !assigned_vars in
- let used =
- (* This doesn't work transitively and thus is somewhat restricted. In
- particular, it does not allow us to get rid of useless chains of [let]s.
- However it should be sufficient to remove the majority of unnecessary
- [let] bindings that might hinder [Cmmgen]. *)
- V.Tbl.fold (fun var _n acc -> V.Set.add var acc)
- t assigned
+ loop ~depth:0 clam;
+ let linear_let_bound_vars, used_let_bound_vars, assigned =
+ V.Tbl.fold (fun var desc ((linear, used, assigned) as acc) ->
+ match desc.uses with
+ | Zero -> acc
+ | One -> (V.Set.add var linear, V.Set.add var used, assigned)
+ | More_than_one -> (linear, V.Set.add var used, assigned)
+ | Assigned -> (linear, V.Set.add var used, V.Set.add var assigned))
+ t (V.Set.empty, V.Set.empty, V.Set.empty)
in
- { used; linear; assigned; closure_environment = !environment_vars;
+ { used_let_bound_vars; linear_let_bound_vars; assigned;
+ closure_environment = !environment_vars;
let_bound_vars_that_can_be_moved = V.Set.empty;
}
| let_bound_var::let_bound_vars, (Uvar arg)::args
when V.same let_bound_var arg
&& not (V.Set.mem arg var_info.assigned) ->
- assert (V.Set.mem arg var_info.used);
- assert (V.Set.mem arg var_info.linear);
+ assert (V.Set.mem arg var_info.used_let_bound_vars);
+ assert (V.Set.mem arg var_info.linear_let_bound_vars);
can_move := V.Set.add arg !can_move;
loop let_bound_vars args
| _::_, _::_ ->
loop body
| _ ->
loop def;
- if V.Set.mem var var_info.linear then begin
+ if V.Set.mem var var_info.linear_let_bound_vars then begin
let_stack := var::!let_stack
end else begin
(* If we encounter a non-linear [let]-binding then we must clear
un_anf_and_moveable var_info env def
| Ulet (let_kind, value_kind, var, def, body) ->
let def, def_moveable = un_anf_and_moveable var_info env def in
- let is_linear = V.Set.mem (VP.var var) var_info.linear in
- let is_used = V.Set.mem (VP.var var) var_info.used in
- let is_assigned = V.Set.mem (VP.var var) var_info.assigned in
+ let is_linear = V.Set.mem (VP.var var) var_info.linear_let_bound_vars in
+ let is_used = V.Set.mem (VP.var var) var_info.used_let_bound_vars in
+ let is_assigned =
+ V.Set.mem (VP.var var) var_info.assigned
+ in
let maybe_for_debugger (body, moveable) : Clambda.ulambda * moveable =
if not !Clflags.debug_full then
body, moveable
what_to_specialise
else
let projections_by_function =
- Variable.Map.filter_map set_of_closures.function_decls.funs
- ~f:(fun _fun_var (function_decl : Flambda.function_declaration) ->
+ set_of_closures.function_decls.funs |> Variable.Map.filter_map
+ (fun _fun_var (function_decl : Flambda.function_declaration) ->
if function_decl.stub then None
else
Some (Extract_projections.from_function_decl ~env
let pignore = "Pignore"
let pint_as_pointer = "Pint_as_pointer"
let pintcomp = "Pintcomp"
+let pcompare_ints = "Pcompare_ints"
+let pcompare_floats = "Pcompare_floats"
+let pcompare_bints = "Pcompare_bints"
let pintofbint = "Pintofbint"
let pintoffloat = "Pintoffloat"
let pisint = "Pisint"
let pignore_arg = "Pignore_arg"
let pint_as_pointer_arg = "Pint_as_pointer_arg"
let pintcomp_arg = "Pintcomp_arg"
+let pcompare_ints_arg = "Pcompare_ints_arg"
+let pcompare_floats_arg = "Pcompare_floats_arg"
+let pcompare_bints_arg = "Pcompare_bints_arg"
let pintofbint_arg = "Pintofbint_arg"
let pintoffloat_arg = "Pintoffloat_arg"
let pisint_arg = "Pisint_arg"
let unit = "unit"
let zero = "zero"
-let anon_fn_with_loc (loc: Location.t) =
+let anon_fn_with_loc (sloc: Lambda.scoped_location) =
+ let loc = Debuginfo.Scoped_location.to_location sloc in
let (file, line, startchar) = Location.get_pos_info loc.loc_start in
let endchar = loc.loc_end.pos_cnum - loc.loc_start.pos_bol in
let pp_chars ppf =
| Plsrint -> plsrint
| Pasrint -> pasrint
| Pintcomp _ -> pintcomp
+ | Pcompare_ints -> pcompare_ints
+ | Pcompare_floats -> pcompare_floats
+ | Pcompare_bints _ -> pcompare_bints
| Poffsetint _ -> poffsetint
| Poffsetref _ -> poffsetref
| Pintoffloat -> pintoffloat
| Plsrint -> plsrint_arg
| Pasrint -> pasrint_arg
| Pintcomp _ -> pintcomp_arg
+ | Pcompare_ints -> pcompare_ints_arg
+ | Pcompare_floats -> pcompare_floats_arg
+ | Pcompare_bints _ -> pcompare_bints_arg
| Poffsetint _ -> poffsetint_arg
| Poffsetref _ -> poffsetref_arg
| Pintoffloat -> pintoffloat_arg
val of_primitive_arg : Lambda.primitive -> t
-val anon_fn_with_loc : Location.t -> t
+val anon_fn_with_loc : Lambda.scoped_location -> t
| Plsrint -> fprintf ppf "lsr"
| Pasrint -> fprintf ppf "asr"
| Pintcomp(cmp) -> Printlambda.integer_comparison ppf cmp
+ | Pcompare_ints -> fprintf ppf "compare_ints"
+ | Pcompare_floats -> fprintf ppf "compare_floats"
+ | Pcompare_bints bi -> fprintf ppf "compare_bints %s" (boxed_integer_name bi)
| Poffsetint n -> fprintf ppf "%i+" n
| Poffsetref n -> fprintf ppf "+:=%i"n
| Pintoffloat -> fprintf ppf "int_of_float"
| Plsrint
| Pasrint
| Pintcomp _ -> No_effects, No_coeffects
+ | Pcompare_ints | Pcompare_floats | Pcompare_bints _
+ -> No_effects, No_coeffects
| Pdivbint { is_safe = Unsafe }
| Pmodbint { is_safe = Unsafe }
| Pdivint Unsafe
opam-version: "2.0"
-version: "4.10.1"
+version: "4.11.0"
synopsis: "OCaml development version"
depends: [
- "ocaml" {= "4.10.1" & post}
+ "ocaml" {= "4.11.0" & post}
"base-unix" {post}
"base-bigarray" {post}
"base-threads" {post}
ROOTDIR = ..
-include $(ROOTDIR)/Makefile.config
-include $(ROOTDIR)/Makefile.common
+-include $(ROOTDIR)/Makefile.config
+-include $(ROOTDIR)/Makefile.common
include $(ROOTDIR)/Makefile.best_binaries
OCAMLRUN ?= $(ROOTDIR)/boot/ocamlrun
LIBCMXFILES = $(LIBCMOFILES:.cmo=.cmx)
LIBCMIFILES = $(LIBCMOFILES:.cmo=.cmi)
-ifeq "$(STDLIB_MANPAGES)" "true"
-DOCS_TARGET = manpages
-else
-DOCS_TARGET =
-endif
-
.PHONY: all
-all: lib exe generators $(DOCS_TARGET)
+all: lib exe generators
.PHONY: exe
exe: $(OCAMLDOC)
.PHONY: clean
clean:
rm -f \#*\#
- rm -f $(OCAMLDOC) $(OCAMLDOC_OPT) *.cma *.cmxa *.cmo *.cmi *.cmx *.cmt *.cmti *.$(A) *.$(O)
+ rm -f $(OCAMLDOC) $(OCAMLDOC_OPT) *.cma *.cmxa *.cmo *.cmi *.cmx *.cmt *.cmti *.a *.lib *.o *.obj
rm -f odoc_parser.output odoc_text_parser.output
rm -f odoc_lexer.ml odoc_text_lexer.ml odoc_see_lexer.ml odoc_ocamlhtml.ml
rm -f odoc_parser.ml odoc_parser.mli odoc_text_parser.ml odoc_text_parser.mli
rm -rf stdlib_man stdlib_html stdlib_texi stdlib_latex
- rm -f generators/*.cm[taiox] generators/*.$(A) generators/*.$(O) generators/*.cmx[as]
+ rm -f generators/*.cm[taiox] generators/*.a generators/*.lib generators/*.o generators/*.obj \
+ generators/*.cmx[as]
.PHONY: depend
depend:
# Define the lists of mli file used by ocamldoc to generate the stdlib
# + otherlibs + compilerlibs documentation
-include $(SRC)/Makefile.config
-include $(SRC)/stdlib/StdlibModules
+-include $(SRC)/Makefile.config
+-include $(SRC)/stdlib/StdlibModules
PARSING_MLIS := $(wildcard $(SRC)/parsing/*.mli)
UTILS_MLIS := $(wildcard $(SRC)/utils/*.mli)
STR_MLIS = $(addprefix $(SRC)/otherlibs/str/, str.mli)
DOC_ALL_INCLUDES = $(DOC_STDLIB_INCLUDES) $(DOC_COMPILERLIBS_INCLUDES)
-STDLIB_MODS = $(STDLIB_MODULES:stdlib__%=%)
-
STDLIB_MOD_WP = $(filter-out stdlib__pervasives, $(STDLIB_MODULES))
-STDLIB_MLI0 = $(SRC)/stdlib/pervasives.ml $(STDLIB_MOD_WP:%=$(SRC)/stdlib/%.mli)
+STDLIB_MLI0 = $(STDLIB_MOD_WP:%=$(SRC)/stdlib/%.mli)
STDLIB_MLIS=\
$(STDLIB_MLI0:$(SRC)/stdlib/stdlib__%=$(SRC)/stdlib/%) \
$(STR_MLIS) \
(** A method to create index files. *)
method generate_elements_index :
'a.
- 'a list ->
- ('a -> Odoc_info.Name.t) ->
- ('a -> Odoc_info.info option) ->
- ('a -> string) -> string -> string -> unit =
- fun elements name info target title simple_file ->
+ ?strip_libname:bool ->
+ 'a list ->
+ ('a -> Odoc_info.Name.t) ->
+ ('a -> Odoc_info.info option) ->
+ ('a -> string) -> string -> string -> unit =
+ fun ?(strip_libname=false) elements name info target title simple_file ->
try
let chanout = open_out (Filename.concat !Global.target_dir simple_file) in
let b = new_buf () in
let f_ele e =
let simple_name = Name.simple (name e) in
let father_name = Name.father (name e) in
- if father_name = "Stdlib" && father_name <> simple_name then
+ if strip_libname &&
+ !Odoc_global.library_namespace <> "" &&
+ father_name = !Odoc_global.library_namespace &&
+ father_name <> simple_name then
(* avoid duplicata *) ()
else
begin
(** Generate the modules index in the file [index_modules.html]. *)
method generate_modules_index _module_list =
self#generate_elements_index
+ ~strip_libname:true
self#list_modules
(fun m -> m.m_name)
(fun m -> m.m_info)
{ Typedtree.ld_id; ld_mutable; ld_type; ld_loc; ld_attributes } =
get_field env comments @@
{Types.ld_id; ld_mutable; ld_type=ld_type.Typedtree.ctyp_type;
- ld_loc; ld_attributes } in
+ ld_loc; ld_attributes; ld_uid=Types.Uid.internal_not_actually_unique} in
let open Typedtree in
function
| Cstr_tuple l ->
ROOTDIR = ..
-include $(ROOTDIR)/Makefile.config
-include $(ROOTDIR)/Makefile.common
+-include $(ROOTDIR)/Makefile.config
+-include $(ROOTDIR)/Makefile.common
include $(ROOTDIR)/Makefile.best_binaries
ifeq "$(filter str,$(OTHERLIBRARIES))" ""
allopt: ocamltest.opt$(EXE)
opt.opt: allopt
-ocamltest$(EXE): $(bytecode_modules)
- $(ocamlc_cmd) -custom ocamlcommon.cma ocamlbytecomp.cma -o $@ $^
+compdeps_names=ocamlcommon ocamlbytecomp
+compdeps_paths=$(addprefix $(ROOTDIR)/compilerlibs/,$(compdeps_names))
+compdeps_byte=$(addsuffix .cma,$(compdeps_paths))
+compdeps_opt=$(addsuffix .cmxa,$(compdeps_paths))
-%.cmo: %.ml
+ocamltest$(EXE): $(compdeps_byte) $(bytecode_modules)
+ $(ocamlc_cmd) -custom -o $@ $^
+
+%.cmo: %.ml $(compdeps_byte)
$(ocamlc) -c $<
-ocamltest.opt$(EXE): $(native_modules)
- $(ocamlopt_cmd) ocamlcommon.cmxa ocamlbytecomp.cmxa -o $@ $^
+ocamltest.opt$(EXE): $(compdeps_opt) $(native_modules)
+ $(ocamlopt_cmd) -o $@ $^
-%.cmx: %.ml
+%.cmx: %.ml $(compdeps_opt)
$(ocamlopt) -c $<
-%.cmi: %.mli
+%.cmi: %.mli $(compdeps_byte)
$(ocamlc) -c $<
%.ml %.mli: %.mly
ocamltest_config.ml: ocamltest_config.ml.in Makefile ../Makefile.config
sed \
-e 's|@@AFL_INSTRUMENT@@|$(AFL_INSTRUMENT)|' \
+ -e 's|@@RUNTIMEI@@|$(RUNTIMEI)|' \
-e 's|@@ARCH@@|$(ARCH)|' \
-e 's|@@SHARED_LIBRARIES@@|$(SUPPORTS_SHARED_LIBRARIES)|' \
-e 's|@@UNIX@@|$(unix)|' \
-e 's|@@OCAMLDOC@@|$(WITH_OCAMLDOC)|' \
-e 's|@@OCAMLDEBUG@@|$(WITH_OCAMLDEBUG)|' \
-e 's|@@OBJEXT@@|$(O)|' \
+ -e 's|@@ASMEXT@@|$(S)|' \
-e 's|@@NATIVE_DYNLINK@@|$(NATDYNLINK)|' \
-e 's|@@SHARED_LIBRARY_CFLAGS@@|$(SHAREDLIB_CFLAGS)|' \
-e 's|@@SHAREDOBJEXT@@|$(SO)|' \
-e 's|@@FUNCTION_SECTIONS@@|$(FUNCTION_SECTIONS)|' \
$< > $@
+# Manual
+
+.PHONY: doc
+
+doc: ocamltest.html
+
+ocamltest.html: ocamltest.org
+ pandoc -s --toc -N -f org -t html -o $@ $<
+
.PHONY: clean
clean:
- rm -rf ocamltest$(EXE) ocamltest.opt$(EXE)
- rm -rf $(o_files) $(ocaml_objects)
+ rm -rf ocamltest ocamltest.exe ocamltest.opt ocamltest.opt.exe
+ rm -rf $(c_files:.c=.o) $(c_files:.c=.obj)
+ rm -rf run_unix.o run_win32.o run_win32.obj
+ rm -rf $(ml_files:.ml=.o) $(ml_files:.ml=.obj)
rm -rf $(cmi_files)
rm -rf $(cmo_files)
rm -rf $(cmx_files)
rm -rf $(generated)
+ rm -f ocamltest.html
ifneq "$(TOOLCHAIN)" "msvc"
.PHONY: depend
(fun log env ->
Environments.dump log env; (Result.pass, env))
+let hasinstrumentedruntime = make
+ "hasinstrumentedruntime"
+ (Actions_helpers.pass_or_skip (Ocamltest_config.has_instrumented_runtime)
+ "instrumented runtime available"
+ "instrumented runtime not available")
+
let hasunix = make
"hasunix"
(Actions_helpers.pass_or_skip (Ocamltest_config.libunix <> None)
fail;
cd;
dumpenv;
+ hasinstrumentedruntime;
hasunix;
hassysthreads;
hasstr;
let diff files =
let temporary_file = Filename.temp_file "ocamltest" "diff" in
- let diff_commandline = String.concat " "
- [
- "diff -u";
- files.reference_filename;
- files.output_filename;
- "> " ^ temporary_file
- ] in
+ let diff_commandline =
+ Filename.quote_command "diff" ~stdout:temporary_file
+ [ "-u";
+ files.reference_filename;
+ files.output_filename ]
+ in
let result =
if (Sys.command diff_commandline) = 2 then Stdlib.Error "diff"
else Ok (Sys.string_of_file temporary_file)
let print_usage () =
Printf.printf "%s\n%!" Options.usage
+type result_summary = No_failure | Some_failure
+let join_summaries sa sb =
+ match sa, sb with
+ | Some_failure, _ | _, Some_failure -> Some_failure
+ | No_failure, No_failure -> No_failure
+
+let summary_of_result res =
+ let open Result in
+ match res.status with
+ | Pass -> No_failure
+ | Skip -> No_failure
+ | Fail -> Some_failure
+
let rec run_test log common_prefix path behavior = function
Node (testenvspec, test, env_modifiers, subtrees) ->
Printf.printf "%s %s (%s) => %!" common_prefix path test.Tests.test_name;
- let (msg, b) = match behavior with
- | Skip_all_tests -> "n/a", Skip_all_tests
+ let (msg, children_behavior, summary) = match behavior with
+ | Skip_all_tests -> "n/a", Skip_all_tests, No_failure
| Run env ->
let testenv0 = interprete_environment_statements env testenvspec in
let testenv = List.fold_left apply_modifiers testenv0 env_modifiers in
let (result, newenv) = Tests.run log testenv test in
- let s = Result.string_of_result result in
- if Result.is_pass result then (s, Run newenv)
- else (s, Skip_all_tests) in
+ let msg = Result.string_of_result result in
+ let children_behavior =
+ if Result.is_pass result then Run newenv else Skip_all_tests in
+ let summary = summary_of_result result in
+ (msg, children_behavior, summary) in
Printf.printf "%s\n%!" msg;
- List.iteri (run_test_i log common_prefix path b) subtrees
+ join_summaries summary
+ (run_test_trees log common_prefix path children_behavior subtrees)
+
+and run_test_trees log common_prefix path behavior trees =
+ List.fold_left join_summaries No_failure
+ (List.mapi (run_test_i log common_prefix path behavior) trees)
+
and run_test_i log common_prefix path behavior i test_tree =
let path_prefix = if path="" then "" else path ^ "." in
let new_path = Printf.sprintf "%s%d" path_prefix (i+1) in
let hookname_prefix = Filename.concat test_source_directory test_prefix in
let test_build_directory_prefix =
get_test_build_directory_prefix test_directory in
- ignore (Sys.command ("rm -rf " ^ test_build_directory_prefix));
+ let clean_test_build_directory () =
+ ignore
+ (Sys.command
+ (Filename.quote_command "rm" ["-rf"; test_build_directory_prefix]))
+ in
+ clean_test_build_directory ();
Sys.make_directory test_build_directory_prefix;
- Sys.with_chdir test_build_directory_prefix
+ let summary = Sys.with_chdir test_build_directory_prefix
(fun () ->
let log =
if !Options.log_to_stderr then stderr else begin
let initial_status =
if skip_test then Skip_all_tests else Run rootenv
in
- List.iteri
- (run_test_i log common_prefix "" initial_status)
- test_trees;
+ let summary =
+ run_test_trees log common_prefix "" initial_status test_trees in
Actions.clear_all_hooks();
- if not !Options.log_to_stderr then close_out log
- );
+ if not !Options.log_to_stderr then close_out log;
+ summary
+ ) in
(* Restore current working directory *)
- Sys.chdir cwd
+ Sys.chdir cwd;
+ begin match summary with
+ | Some_failure -> ()
+ | No_failure ->
+ if not !Options.keep_test_dir_on_success then
+ clean_test_build_directory ()
+ end
let is_test s =
match tsl_block_of_file s with
Ocaml_variables.shared_library_cflags,
Ocamltest_config.shared_library_cflags;
Ocaml_variables.objext, Ocamltest_config.objext;
+ Ocaml_variables.asmext, Ocamltest_config.asmext;
Ocaml_variables.sharedobjext, Ocamltest_config.sharedobjext;
Ocaml_variables.ocamlc_default_flags,
Ocamltest_config.ocamlc_default_flags;
let compilerlibs_subdirs =
[
- "utils"; "parsing"; "toplevel"; "typing"; "bytecomp"; "compilerlibs";
- "file_formats"; "lambda";
+ "asmcomp";
+ "bytecomp";
+ "compilerlibs";
+ "driver";
+ "file_formats";
+ "lambda";
+ "middle_end";
+ "parsing";
+ "toplevel";
+ "typing";
+ "utils";
]
let add_compiler_subdir subdir =
Append (Ocaml_variables.directories, (wrap (compiler_subdir [subdir])))
-let ocamlcommon =
- (Append (Ocaml_variables.libraries, wrap "ocamlcommon")) ::
+let compilerlibs_archive archive =
+ (Append (Ocaml_variables.libraries, wrap archive)) ::
(List.map add_compiler_subdir compilerlibs_subdirs)
let debugger = [add_compiler_subdir "debugger"]
register_modifiers "unix" unix;
register_modifiers "dynlink" dynlink;
register_modifiers "str" str;
- register_modifiers "ocamlcommon" ocamlcommon;
+ List.iter
+ (fun archive -> register_modifiers archive (compilerlibs_archive archive))
+ [
+ "ocamlcommon";
+ "ocamlbytecomp";
+ "ocamlmiddleend";
+ "ocamloptcomp";
+ "ocamltoplevel";
+ ];
register_modifiers "systhreads" systhreads;
register_modifiers "latex" latex;
register_modifiers "html" html;
let objext = make ("objext",
"Extension of object files")
+let asmext = make ("asmext",
+ "Extension of assembly files")
+
let ocamlc_byte = make ("ocamlc_byte",
"Path of the ocamlc.byte executable")
modules;
nativecc_libs;
objext;
+ asmext;
ocamlc_byte;
ocamlopt_byte;
ocamlrun;
(** Libraries to link with for native code *)
val objext : Variables.t
+val asmext : Variables.t
val ocamlc_byte : Variables.t
val ocamlopt_byte : Variables.t
--- /dev/null
+#+STARTUP: showall
+
+#+title: The ocamltest reference manual
+#+language: en
+
+#+HTML_HEAD: <style> body { font-size: 1rem; max-width: 900px; margin: 0 auto; } </style>
+
+* Introduction
+
+This is =verbatim= and this is ~code~.
+
+** What is ocamltest
+
+ocamltest is a test-driver, that is, a program that can run tests and report
+their results so that they can be used by a test infrastructure.
+
+Originally, the tool has been designed specifically to run the integration
+tests of the OCaml compiler's test suite. However, it has been
+designed with extensibility in mind and thus has a plugin
+mechanism that makes it possible to extend it with other tests.
+
+** Design choices
+
+*** Programming language and external dependencies
+
+For a start, one may wonder in which language a test-driver for a compiler
+should be written. It may indeed seem odd to write a test-driver for a
+compiler in the language it compiles, since the compiler itself
+is yet untested and thus not trustworthy.
+
+It can however be observed that the OCaml compiler is /bootstraped/,
+meaning that it is itself written in OCaml. A newer version of the
+compiler can thus be produced from an existing one and the (OCaml)
+source code of that newer version. Practically, this means that the
+compiler works at least well enough to recompile itself. This is why we
+consider that it is okay to write a test-driver like ocamltest in OCaml,
+as long as it uses only code that has been used to bootstrap the
+compiler. In particular, this is why we prefer not to rely on any
+external dependency, not even the libraries included in the compiler
+distribution such as the =Unix= library.
+
+*** Test types
+
+As has been noted above, ocamltest has been developed to run the already
+existing integration tests of the OCaml compiler's test suite, which
+were previously run by a set of makefiles. This context explains
+several design decisions which could otherwise seem rather arbitrary.
+
+For example, the reason why ocamltest has no support for running unit tests
+is that there were no such tests in the OCaml compiler's test suite.
+
+Indeed, the OCaml compiler's test suite is composed mainly of complete
+programs. In this context, the most current meaning of "testing" a program
+is that the program needs to be compiled and executed. The test will
+be considered successful if the program compiles as expected and, when run,
+returns the expected value.
+
+Since this scenario is the most frequent one, it was of particular
+importance to make writing tests of this form as simple as possible.
+
+However, not all tests fall into the previously described category, so it is
+also necessary to support not only variations on the previous scenario
+(compile but do not run, compile with certain options, etc.) but also
+completely different tests, such as top-level tests, debugger tests,
+etc.
+
+To fulfill these requirements and make it as easy as possible to turn a
+program into a test, it has been chosen to design a Domain-Specific
+Language (DSL) used to annotate the test program with a
+=(* TEST *)= block at its top. This block specifies how the test
+should be performed.
+
+** Outline of this document
+
+The next chapter explains through examples how to write simple tests. We
+then introduce the key concepts used by ocamltest to provide a better
+understanding of how it works and can be used to write more complex
+tests. The two last chapters give an in-depth description of the
+built-in tests and actions and of the tests and actions that are specific
+to the OCaml compiler.
+
+* Writing simple tests
+
+This chapter is a tutorial. It explains how to write simple test
+programs and also tries to give insights about how ocamltest works. These
+insights will be deepened in chapter [[#concepts]] where ocamltest is
+presented in a more abstract and conceptual way.
+
+We start by explaining how to set-up a proper environment for writing
+tests. We then show how to turn the traditional "Hello, world!" program
+into a test and explain how to run it with ocamltest. We continue
+with a few variations on this test and conclude this chapter
+with a few other useful tests.
+
+** Prerequisites for writing tests
+
+Writing tests requires that the sources of the OCaml compiler for which
+one wants to write them are downloaded and compiled. The compiler
+does not need to be installed, though.
+
+The sources can be downloaded either as an archive, or directly cloned
+through git, which seems more appropriate in the context of writing ones
+own tests. Refer to
+=INSTALL.adoc= (and also to =README.win32.adoc= if you are on Windows) to
+learn how to get the sources of the OCaml compiler and to compile them.
+
+In the remainder of this manual, we will assume that the sources of the
+OCaml compiler have been extracted in the =${OCAMLSRCDIR}= directory (for
+instance =${HOME}/src/ocaml=) and that you have successfully configured
+and compiled them as described in =INSTALL.adoc= or =README.win32.adoc=,
+according to your operating system. The tools and libraries necessary
+for running tests should also be built. This can be achieved by running
+the following command from =${OCAMLSRCDIR}=:
+: make -C testsuite lib tools
+
+We will also assume that an =ocamltest= command is available in
+your =PATH=. Although this is not strictly necessary, it is strongly
+recommended that you set this up because this will simplify test
+development a lot. This can be achieved e.g. by creating a symbolic
+link to =${OCAMLSRCDIR}/ocamltest/ocamltest= (or its native
+counterpart =${OCAMLSRCDIR}/ocamltest/ocamltest.opt=) in a directory that
+is already in your =PATH=, like =~/bin=.
+
+** Testing the "Hello, world!" program with the default tests
+
+*** Turning "Hello, world!" into a useful test program
+
+Consider the following OCaml implementation of the classical "Hello, world!"
+program written to a =hello.ml= file:
+
+: let _ = print_endline "Hello, world!"
+
+Now assume we would like to make sure that the OCaml compiler can
+compile this program and that the resulting executable indeed prints the
+expected output. Here are the required steps to turn the program
+above into a test usable by ocamltest to verify this:
+
+1. First, we add a special comment at the very beginning of our =hello.ml=
+ file to make it explicit that it is a test:
+ #+begin_src
+ (* TEST *)
+
+ let _ = print_endline "Hello, world!"
+ #+end_src
+
+2. We then need to say what the expected outputs are. In our case, we
+ expect that compiling the test produces no output at all and that its
+ execution produces one single line:
+ : Hello, world!
+ To let ocamltest know about this, we create a =hello.reference= file
+ containing the program's expected output -- the line mentioned
+ above. There is nothing special to do for silent compilations
+ since this is what is expected by default and a non-silent
+ compilation would actually cause a test failure.
+
+3. We can now ask ocamltest to run our test program with the
+ following command:
+ : ocamltest hello.ml
+
+ Running this would produce an output similar to this one:
+
+ #+begin_src
+ ... testing 'hello.ml' with 1 (native) => passed
+ ... testing 'hello.ml' with 2 (bytecode) => passed
+ #+end_src
+
+ In addition to this output, it may be noticed that the previous
+ command has also created an =_ocamltest= directory whose content will
+ be examined in the next sub-section.
+
+4. Finally, there is one extra step required if we want our newly created
+ test to be run automatically as part of the OCaml compiler's test suite.
+ We need to move =hello.ml= and =hello.reference= to a directory (say
+ =newtest=) located somewhere
+ below =testsuite/tests= in the compiler's source tree and we
+ need to declare the test. This is done by appending the name of the
+ file containing the =(* TEST *)= comment to an =ocamltests=
+ (mark the final s) file located in the =newtest= directory,
+ alongside the other files relevant to the test. Once this is done,
+ the command
+ : make all
+ executed in the =testsuite= directory of the OCaml compiler' source
+ tree will run all the test suite, which now also includes our own test.
+
+*** What exactly is going on during the test
+
+The only thing we know from ocamltest's output when run on =hello.ml= is
+that it is running two tests named =bytecode= and =native= and that the two of
+them succeed. This can seem rather uninformative, and in a way it is, but
+it has to be kept in mind that this information is the one passed by the
+test-driver (ocamltest) to the test infrastructure. In that respect,
+this is enough. For us users, though, it is not. That's why
+ocamltest logs much more details about what is going on in a per-test
+log file, which should be located in the =_ocamltest/hello/hello.log= file
+found in the directory where =hello.ml= is.
+
+Before looking at this log file, notice that it has been created in a
+test-specific directory. ocamltest creates such a directory for each
+file it tests and makes sure every file produced as a result of
+testing this file will be placed in this directory, either directly, or
+in one of its sub-directories. The latter happens if the test has
+to be compiled several times, with the same compiler and different
+command-line options, or with different compilers. In particular,
+in order to better understand what follows, it may be helpful to
+remember that =OCaml= actually consists in not less than four compilers:
+=ocamlc.byte= and =ocamlc.opt= which are the bytecode and native
+flavors of the bytecode compiler and =ocamlopt.byte= and
+=ocamlopt.opt= which are the bytecode and native flavors of the native
+compiler. So, as we will see, ''testing the bytecode compiler''
+actually involves testing two compilers, and the same goes for ''testing
+the native compiler''.
+
+Now that all this has been spelled out, let's examine the log file
+produced by the test. Although it is too long to be reproduced here,
+it is recommended to go through it quickly to get an idea of its
+structure. Here is how it starts:
+
+#+begin_src
+Specified modules: hello.ml
+Source modules: hello.ml
+#+end_src
+
+The first line lists the names of the modules the test consists of. The
+second line is almost similar but if some modules had separate
+interface files, they would be listed here, too, without the user
+having to specify them in the list of modules (for each specified =.ml=
+file, ocamltest looks whether a corresponding =.mli= file exists and, if
+so, adds it to the list of files to consider).
+
+The rest of the log file can be split into two parts which are very
+similar to each other: one for the =native= test and one for the =bytecode=
+test. Among other things, we learn that each of these tests is composed
+of nine actions. Before diving into the details of what each of these
+actions does, let us take this opportunity to introduce a bit of
+ocamltest terminology. An /action/ is anything that can =pass=, =skip= or
+=fail=. A =test= is a sequence of such actions. Running
+a test thus means running each of its actions, in sequence, until all the
+actions have been run or one of them returns =pass= or =skip=. Whatever
+the last run action returns, this value will be the result of the whole
+test.
+
+To give concrete examples of actions, let's briefly go over the nine ones
+involved in the =bytecode= test (those for the =native= test are
+quite similar):
+
+1. =setup-ocamlc.byte-build-env=:: as its name suggests, this action
+ creates a build environment where a program can be compiled and
+ executed using the =ocamlc.byte= compiler. More precisely, this
+ involves creating a dedicated directory under the test-file specific
+ directory and populating it with the files required by subsequent actions.
+ Depending on what the underlying operating system supports, the files
+ will be either symlinked or copied from the test source directory.
+
+2. =ocamlc.byte=:: invokes the =ocamlc.byte= compiler in various ways.
+ Here, the test program is compiled and linked, but as we will see
+ later, different behaviors are possible depending on ocamltest
+ /variables/.
+
+3. =check-ocamlc.byte-output=:: this action compares the compiler's
+ output to a reference file, if one exists. As has been mentioned
+ earlier, the absence of such a reference file specifies that the
+ compiler's output is expected to be empty -- if it is not, this
+ causes a failure of this action and thus of the whole =bytecode=
+ test.
+
+4. =run=:: now that the program has been successfully compiled, it is
+ run with its standard output and error streams saved to a file.
+
+
+5. =check-program-output=:: this time it is the output of the program
+ which is compared to a reference file, namely the =hello.reference=
+ file created earlier. So far this comparison succeeds, because the
+ output of the program is identical to the reference file but, as an
+ exercise, one may try to modify the reference file to see how this
+ causes the failure of this action and of the whole =bytecode= test.
+
+ This action concludes the test of the =ocamlc.byte= compiler. We now
+ know that it is able to successfully compile our test program and that
+ the resulting executable runs as expected. The four remaining actions
+ are going to test the =ocamlc.opt= compiler in a similar but not
+ identical way:
+
+6. =setup-ocamlc.opt-build-env=:: this action is the counterpart of
+ action 1 for the =ocamlc.opt= compiler.
+
+7. =ocamlc.opt=:: like action 2, this action compiles the test program
+ but with the =ocamlc.opt= compiler.
+
+8. =check-ocamlc.opt-output=:: again, this action is similar to
+ action 3.
+
+9. =compare-bytecode-programs=:: here we make sure that the generated
+ executable is correct, but in a different way than for the
+ =ocamlc.byte= compiler. Rather than running it and checking its
+ output, we compare it to the one produced in action 2. Such a check
+ may seem strange, because what it requires is that =ocamlc.byte= and
+ =ocamlc.opt= produce exactly the same binary and not two binaries
+ than perform similarly when they are run, but it has proven useful in
+ the past and has permitted to detect a subtle bug in the compiler.
+
+** Customizing the default tests
+
+As has been briefly mentioned, the precise behavior of actions (and
+thus of tests) may depend on /variables/ whose value can be adjusted in
+the =(* TEST ... *)= blocks. In ocamltest, all the values of variables
+are strings. Here are a few examples of things that can be achieved just
+by defining the appropriate variables. The complete description of the
+actions provided by ocamltest and the variables they use will be given
+in chapters [[#builtins]] and [[#ocaml-specific]].
+
+*** Passing flags to the compilers
+
+Assume our =hello.ml= example is modified as follows:
+
+#+begin_src
+(* TEST *)
+
+open Format
+
+let _ = print_endline "Hello, world!"
+#+end_src
+
+As may be verified, this program still passes the default tests. It is
+however not as minimal as our previous version, because the =Format=
+module is opened but not used. Fortunately, OCaml has a warning to
+detect such unused =open= directives, namely warning 33, which is
+disabled by default. We could thus add this version of =hello.ml=
+to the test suite, not so much to verify that the program compiles and
+runs as expected (we verified this already), but rather to make sure
+the compiler does indeed trigger the expected warning. Here are the
+required steps to achieve this:
+
+1. We slightly modify the test block in =hello.ml=, as follows:
+ #+begin_src
+ (* TEST
+ flags = "-w +33"
+ *)
+ #+end_src
+
+2. Since we now expect a non-empty output for the compilers, we need to
+ store the expected output in a file, namely =hello.compilers.output=
+ besides to =hello.ml= and =hello.reference=. To figure out what
+ this file shall contain, we can run ocamltest even before it
+ has been created. Of course, the action that checks compiler output
+ will fail, but in this way we will get the compiler's output
+ which we will just have to check (to
+ make sure it is what we expect) and to move to the reference file.
+ Thus, we do:
+ : $ ocamltest hello.ml
+ which fails, unsurprisingly, and shows us the paths to the file
+ containing the output produced by the compiler and the path to the
+ expected reference file. We also see what the compiler produced as
+ output but we can double-check that the output is what we expect as a
+ reference:
+ : $ cat _ocamltest/hello/ocamlc.byte/ocamlc.byte.output
+ which shows the warning we expect from the compiler. We can thus move
+ this file to the reference file:
+ : $ mv _ocamltest/hello/ocamlc.byte/ocamlc.byte.output hello.compilers.reference
+ and if we now run ocamltest again, all the tests pass.
+
+Two remarks are due. First, we have used the =flags= variable, to pass
+extra flags to all the compilers. There are two other variables one can
+use, namely =ocamlc_flags= and =ocamlopt_flags=, to pass flags to the
+bytecode or native compilers. Second, in this test all the compilers
+have the same output so one reference file is enough for all of them.
+There are situations, though, where the compiler's output is
+back-end-specific (it depends whether we compile to bytecode or to native
+code) or even compiler-specific. ocamltest is clever enough to know how
+to deal with such situations, provided that the reference files are
+named appropriately. It will indeed first lookup the test source
+directory for a compiler-specific reference file, e.g.
+=hello.ocamlc.byte.reference=. If no such file exists, a
+back-end-specific reference file is searched, e.g.
+=hello.ocamlc.reference= for a compiler common to both =ocamlc.byte= and
+=ocamlc.opt=. If this file does not exist either, ocamltest falls back
+to looking for =hello.compilers.reference= as we have seen in this
+example, the absence of which meaning that the compiler's output is
+expected to be empty.
+
+*** Using an auxiliary module
+
+Let's start with our original =hello.ml= test program and extract the
+greeting logic into a distinct =greet.ml= module:
+
+#+begin_src
+let greet guest = Printf.printf "Hello, %s!\n" guest
+#+end_src
+
+Let's also write an interface, =greet.mli=:
+
+#+begin_src
+val greet : string -> unit
+#+end_src
+
+Our =hello.ml= test program can then be rewritten as follows:
+
+#+begin_src
+(* TEST
+modules = "greet.ml"
+*)
+
+let _ = Greet.greet "world"
+#+end_src
+
+Provided that the =hello.compilers.reference= file previously to test
+warnings is deleted, running ocamltest on =hello.ml= should work. It
+will also be worth looking at the two first lines of the log file generated
+while running the test. It says:
+
+#+begin_src
+Specified modules: greet.ml hello.ml
+Source modules: greet.mli greet.ml hello.ml
+#+end_src
+
+The first line shows that the =modules= variable has been taken into
+account. On the second line, it can be seen that the =greet.mli= file
+appears, right before =greet.ml=. It is ocamltest that has added it,
+because it has been recognized as an interface for one of the specified
+modules.
+
+To sum up, if a test consists in several modules, it is enough to list
+their implementations (except the one of the main test program which is
+implicit) in the =modules= variable, in linking order. There is no need
+to worry about their interfaces, which will be added automatically by
+ocamltest, if they exist.
+
+*** Linking with a library
+
+Assume we want to use the following program to make sure regular
+expressions as implemented by the =Str= library work as expected:
+
+#+begin_src
+let hello_re = Str.regexp "^Hello, .+!$"
+
+let hello_str = "Hello, world!"
+
+let _ =
+ if not (Str.string_match hello_re hello_str 0) then
+ begin
+ Printf.eprintf "There is a problem!\n";
+ exit 2
+ end
+#+end_src
+
+This test terminates silently if everything goes well and prints a
+message on its standard error only if something goes wrong, which means
+we won't have anything special to do so that ocamltest checks for an
+empty output after the program has run. However, to be able to compile
+and link this test, there are several things we need to do so that it
+finds the =Str= library it uses. More precisely, we need to add the =-I=
+option pointing to the right directory and, at link time, to give the
+name of the appropriate library file. To make our life a bit simpler,
+ocamltest has a few variables where directories and libraries can be
+listed. Once they are there, it is ocamltest which will take care of
+adding the =-I= option for each directory and for adding the right
+library file depending on whether we are producing bytecode or native
+programs. So, here is how the previous program can be annotated so that
+it becomes a test:
+
+#+begin_src
+(* TEST
+directories += " ${ocamlsrcdir}/otherlibs/str "
+libraries += " str "
+*)
+#+end_src
+
+With these annotations, it becomes possible to run =re.ml= as an
+ocamltest test program and, doing so, one may notice that the two tests
+pass. There are however a few other things worth pointing out here
+regarding the ocamltest DSL. For a start, the notation =${variable}=
+inside a string means to replace =variable= by its value, as happens in
+many other languages, like the bash shell. Moreover, it is the first
+time we meet the ~+=~ operator which concatenates a value to a variable.
+More precisely,
+: foo += "bar"
+is equivalent to
+: foo = "${foo}bar"
+and not to
+: foo = "${foo} bar"
+as it may happen in other languages such as makefiles.
+
+In other words, the ~+=~ operator concatenates two strings without
+inserting any implicit space between them as e.g. make would do. This is
+because in some cases such a behavior is required and could not be
+achieved if spaces were implicitly added, whereas with a literal
+concatenation it is always possible to include spaces explicitly. This is
+exactly what happens in the ocamltest annotation block above, where the
+strings added to the =libraries= and =directories= variables are
+surrounded by spaces. As should be clear to the reader by now, these
+spaces are mandatory. Without them, the added values would be glued to
+the last word of the variable and would thus be misinterpreted.
+
+Finally, one may notice that, although ocamltest does make it
+possible to link a test program with a library, it does not really make
+it easy or convenient to do so. In particular, what if we want to write
+several, perhaps many test programs that need to be linked with =Str=?
+Will we have to repeat these lines everywhere, thus creating code that
+is going to be tedious to maintain? Well, fortunately not. Actually,
+ocamltest has a much more elegant way to deal with such issues, namely
+/environment modifiers/. As will be explained in chapter [[#concepts]], an
+/environment modifier/ is an object that gathers several variable
+definitions that can then be included in an ocamltest block at once.
+Environment modifiers have to be defined in ocamltest itself and can
+then be used with the =include= directive. For instance, the previous
+test block is actually written as follows:
+
+#+begin_src
+(* TEST
+include str
+*)
+#+end_src
+
+*** Testing only on Unix systems
+
+So far, we have been able to fulfill our requirements just by assigning
+the right values to variables and relying on the =bytecode= and =native=
+tests ocaml runs by default. There are however situations where this is
+not enough and where one needs the ability to run other tests. One
+example of such a situation is when a test needs to be performed only on
+one given operating system, e.g. because it uses a feature which is
+present only on that operating system. On an other operating system, the
+test should be skipped because it is irrelevant. To illustrate this,
+here is how our original =hello.ml= test program should be annotated so
+that it is run only on Unix platforms:
+
+#+begin_src
+(* TEST
+:* unix
+:** bytecode
+:** native
+*)
+#+end_src
+
+As can be understood from this example, lines starting with an asterisk
+describe which tests should be executed. In addition, the number of
+asterisks allows to specify the nesting level of each test or action.
+Here for instance, =bytecode= and =native= are sub-tests that will be
+run only if the =unix= test passes and will not be started if it fails
+or skips.
+
+This way of describing the dependencies between tests has been inspired
+by the syntax of org-mode. Each line starting with asterisks (thus lines
+specifying which tests to run) can also be seen as a title. The whole
+set of lines is like the outline of the test scenario.
+
+With this information in mind, it can be seen that the smallest test
+block
+: (* TEST *)
+is actually equivalent to
+#+begin_src
+(* TEST
+:* bytecode
+:* native
+*)
+#+end_src
+
+One common error when designing tests is to believe that a block like
+#+begin_src
+(* TEST
+:* unix
+*)
+#+end_src
+means to execute the =unix= test that verifies that the OS is indeed
+Unix and then to execute the default tests. This is actually not the
+case. The only situation in which the default tests are considered is
+when the test block contains absolutely no line starting with an
+asterisk. As soon as there is a line starting with an asterisk, the
+default tests are ignored completely and one needs to be totally
+explicit about which tests to run. So the correct way to write the
+erroneous block above is the use shown at the beginning of this section,
+namely:
+#+begin_src
+(* TEST
+:* unix
+:** bytecode
+:** native
+*)
+#+end_src
+
+The fact that the language is inspired by org-mode should also be
+helpful in understanding the scope of variable assignments. Roughly
+speaking:
+
+1. Variables defined at the root level are visible by all the tests and
+ sub-tests that follow their assignment.
+
+2. If a variable is defined just below a test line, then it is visible
+ by that test and all its sub-tests (unless its definition is
+ overridden) but not by tests at a nesting level whose depth is less or
+ equal than the one of the test in which the variable is defined.
+
+For instance, given the following block:
+#+begin_src
+(* TEST
+foo = "abc"
+:* test1
+bar = "def"
+:** subtest1
+baz = "hij"
+:** subtest2
+:* test2
+*)
+#+end_src
+- The definition of =foo= is visible in all the tests
+
+- The definition of =bar= is visible in all the tests except =test2=.
+
+- The definition of =baz= is visible only in =subtest1=.
+
+** Other useful tests
+
+This section introduces three tests provided by =ocamltest= and that can
+be of particular interest. A complete list of available tests and
+actions and their detailed descriptions are given in chapters
+[[#builtins]] and [[#ocaml-specific]].
+
+*** Testing the top-level: the =toplevel= and =expect= tests
+
+Two tests are provided to make sure that the OCaml top-level behaves as
+expected: =toplevel= and =expect=. These tests are similar in that they
+both allow to test how the OCaml top-level reacts to some user input,
+but they are different in the way one specifies the expected output and
+also in what they can test. The =toplevel= test behaves in a spirit
+similar to the compiler tests described above, meaning that the expected
+output has to be stored in its own, separate file. Since this test
+invokes the real OCaml top-level, it is useful to test advanced features
+like the behavior of the top-level when its input is a file rather than
+a terminal, or similar things. In the expect test, on the contrary,
+the input and the output it is expected to produce can be written in
+the same file, close to each other. However, this test uses the OCaml
+top-level as a library, rather than calling it as an external program.
+So this test is actually not testing the complete real OCaml top-level,
+but for testing language features it remains perfectly valid and is
+actually what is needed in most of the cases. We thus give below an
+example of an expect test and will describe the =toplevel= test in
+chapter [[#ocaml-specific]].
+
+So, here is a toy example of an =expect= test:
+
+#+begin_src
+(* TEST
+:* expect
+*)
+
+type point = { x : int; y : int };;
+[%%expect{|
+type point = { x : int; y : int; }
+|}];;
+#+end_src
+
+The first line after the test block is the input phrase, while the line
+that appears between =[%%expect{|= and =|}];;= is the corresponding
+expected output. The =expect= test can also be used to test the output
+in presence of the =-principal= command-line flag. In such cases, the
+expected output should be written in a =|}, Principal{|= block (to be
+improved).
+
+*** The =script= test
+
+It may happen that a needed test is not provided by ocamltest. Of
+course, if it turns out that this test would be helpful to test several
+source files, then the best solution is to add it to ocamltest itself.
+Some tests are however so specific that it is easier to write them as
+shell scripts. Such tests can be run by the =script= test, their name
+being defined by the =script= variable. In this case, the script is run
+in an environment where all the variables defined in ocamltest have been
+exported. The script uses its exit status to report its result and can
+write a response to a dedicated file to modify its environment or
+explain why it failed or skipped, as will be explained in chapter
+[[#builtins]]. For the moment, let's see how to use a script to "test" our
+original =hello.ml= example. Our annotated program would look as
+follows:
+
+#+begin_src
+(* TEST
+script = "${test_source_directory}/faketest.sh"
+:* script
+*)
+
+let _ = print_endline "Hello, world!"
+#+end_src
+
+And here is =faketest.sh=, make sure it is executable:
+
+#+begin_src
+#!/bin/sh
+exit ${TEST_PASS}
+#+end_src
+
+This should be enough for the following command to work:
+: ocamltest hello.ml
+
+This of course tests nothing and a real test script should actually do
+something before returning its result. Let's however see how we can
+make the script test fail gracefully:
+
+#+begin_src
+#!/bin/sh
+echo Why should this pass in the first place > ${ocamltest_response}
+exit ${TEST_FAIL}
+#+end_src
+
+Running ocamltest on our =hello.ml= program again produces the following
+output:
+#+begin_src
+ ... testing 'hello.ml' with 1 (script) => failed (Why should this pass in the first place)
+#+end_src
+
+* Key concepts
+ :PROPERTIES:
+ :CUSTOM_ID: concepts
+ :END:
+
+** Actions, hooks and tests
+
+** Semantics of a test block
+
+** Variables, environments and how they are inherited
+
+** Environment modifiers
+
+* Built-in actions and tests
+ :PROPERTIES:
+ :CUSTOM_ID: builtins
+ :END:
+
+* OCaml-specific actions and tests
+ :PROPERTIES:
+ :CUSTOM_ID: ocaml-specific
+ :END:
+
+# Things to document (requested by Leo on caml-devel)
+# - the syntax of the DSL
+# - the precise meaning of the stars
+# - a clear definition of what "test" means in the context of the DSL
+# - a list of the builtin "actions"
+# - a list of which "actions" depend on which "variables"
+# - what does "include" do?
+# - what is the scoping of variables?
+
+# LocalWords: ocamltest OCaml DSL extensibility makefiles
+
+# Local Variables:
+# ispell-local-dictionary: "english"
+# End:
let objext = "@@OBJEXT@@"
+let asmext = "@@ASMEXT@@"
+
let system = "@@SYSTEM@@"
let c_preprocessor = "@@CPP@@"
let windows_unicode = @@WINDOWS_UNICODE@@ != 0
let function_sections = @@FUNCTION_SECTIONS@@
+
+let has_instrumented_runtime = @@RUNTIMEI@@
val objext : string
(** Extension of object files *)
+val asmext : string
+(** Extension of assembly files *)
+
val system : string
(** The content of the SYSTEM Make variable *)
val function_sections : bool
(** Whether the compiler was configured to generate
each function in a separate section *)
+
+val has_instrumented_runtime : bool
+(** Whether the instrumented runtime is available *)
let mkdir dir =
if not (Sys.file_exists dir) then
- let quoted_dir = "\"" ^ dir ^ "\"" in
- run_system_command ("mkdir " ^ quoted_dir)
+ run_system_command (Filename.quote_command "mkdir" [dir])
let rec make_directory dir =
if Sys.file_exists dir then ()
let promote = ref false
+let keep_test_dir_on_success = ref false
+
let find_test_dirs = ref []
let list_tests = ref []
" Find directories that contain tests (recursive).");
("-list-tests", Arg.String (add_to_list list_tests),
" List tests in given directory.");
+ ("-keep-test-dir-on-success", Arg.Set keep_test_dir_on_success,
+ " Keep the test directory (with the generated test artefacts) on success.");
]
let files_to_test = ref []
val find_test_dirs : string list ref
val list_tests : string list ref
+
+val keep_test_dir_on_success : bool ref
if (WIFEXITED(status)) return WEXITSTATUS(status);
if ( !WIFSIGNALED(status) )
- error("Process %d neither terminated normally nor received a" \
- "signal!?", pid);
+ error("Process %lld neither terminated normally nor received a" \
+ "signal!?", (long long) pid);
/* From here we know that the process terminated due to a signal */
signal = WTERMSIG(status);
#endif /* WCOREDUMP */
corestr = core ? "" : "no ";
fprintf(stderr,
- "Process %d got signal %d(%s), %score dumped\n",
- pid, signal, strsignal(signal), corestr
+ "Process %lld got signal %d(%s), %score dumped\n",
+ (long long) pid, signal, strsignal(signal), corestr
);
if (core)
fprintf(stderr, "Out of memory while processing core file.\n");
else {
snprintf(corefile, corefile_len,
- "%s.%d.core", corefilename_prefix, pid);
+ "%s.%lld.core", corefilename_prefix, (long long) pid);
if ( rename(COREFILENAME, corefile) == -1)
fprintf(stderr, "The core file exists but could not be renamed.\n");
else
#**************************************************************************
ROOTDIR=..
-include $(ROOTDIR)/Makefile.config
-include $(ROOTDIR)/Makefile.common
+-include $(ROOTDIR)/Makefile.config
+-include $(ROOTDIR)/Makefile.common
+
+OTHERLIBRARIES ?= bigarray dynlink raw_spacetime_lib str systhreads \
+ unix win32unix
# $1: target name to dispatch to all otherlibs/*/Makefile
define dispatch_
# Common Makefile for otherlibs
ROOTDIR=../..
-include $(ROOTDIR)/Makefile.config
-include $(ROOTDIR)/Makefile.common
+-include $(ROOTDIR)/Makefile.config
+-include $(ROOTDIR)/Makefile.common
include $(ROOTDIR)/Makefile.best_binaries
CAMLRUN ?= $(ROOTDIR)/boot/ocamlrun
ROOTDIR = ../..
-include $(ROOTDIR)/Makefile.config
-include $(ROOTDIR)/Makefile.common
+-include $(ROOTDIR)/Makefile.config
+-include $(ROOTDIR)/Makefile.common
include $(ROOTDIR)/Makefile.best_binaries
CAMLRUN ?= $(ROOTDIR)/boot/ocamlrun
-OCAMLC=$(BEST_OCAMLC) -nostdlib -I $(ROOTDIR)/stdlib
-OCAMLOPT=$(BEST_OCAMLOPT) -nostdlib -I $(ROOTDIR)/stdlib
+OCAMLC=$(BEST_OCAMLC) -g -nostdlib -I $(ROOTDIR)/stdlib
+OCAMLOPT=$(BEST_OCAMLOPT) -g -nostdlib -I $(ROOTDIR)/stdlib
# COMPFLAGS should be in sync with the toplevel Makefile's COMPFLAGS.
COMPFLAGS=-strict-sequence -principal -absname -w +a-4-9-40-41-42-44-45-48-66 \
utils/terminfo.ml \
utils/warnings.ml \
utils/load_path.ml \
+ utils/int_replace_polymorphic_compare.ml \
parsing/location.ml \
parsing/longident.ml \
parsing/docstrings.ml \
file_formats/cmi_format.ml \
typing/persistent_env.ml \
typing/env.ml \
+ lambda/debuginfo.ml \
lambda/lambda.ml \
lambda/runtimedef.ml \
bytecomp/instruct.ml \
# Rules to make a local copy of the .ml and .mli files required. We also
# provide .ml files for .mli-only modules---without this, such modules do
# not seem to be located by the type checker inside bytecode packs.
+# Note: .ml-only modules are not supported by the (.mli.cmi) rule below.
$(LOCAL_SRC)/Makefile: $(LOCAL_SRC)/Makefile.copy-sources Makefile
cp -f $< $@
COMPILERLIBS_CMO=$(COMPILERLIBS_COPIED_SOURCES:.ml=.cmo)
COMPILERLIBS_CMX=$(COMPILERLIBS_COPIED_SOURCES:.ml=.cmx)
-$(LOCAL_SRC)/%.cmi:
+$(LOCAL_SRC)/%.cmi: $(LOCAL_SRC)/%.mli
$(OCAMLC) -c -for-pack Dynlink_compilerlibs $(COMPFLAGS) \
-I $(LOCAL_SRC) -o $@ $(LOCAL_SRC)/$*.mli
-$(LOCAL_SRC)/%.cmo:
+$(LOCAL_SRC)/%.cmo: $(LOCAL_SRC)/%.ml
$(OCAMLC) -c -for-pack Dynlink_compilerlibs $(COMPFLAGS) \
-I $(LOCAL_SRC) -o $@ $(LOCAL_SRC)/$*.ml
-$(LOCAL_SRC)/%.cmx:
+$(LOCAL_SRC)/%.cmx: $(LOCAL_SRC)/%.ml
$(OCAMLOPT) -c -for-pack Dynlink_compilerlibs $(COMPFLAGS) \
$(OPTCOMPFLAGS) -I $(LOCAL_SRC) -o $@ $(LOCAL_SRC)/$*.ml
partialclean:
rm -f extract_crc *.cm[ioaxt] *.cmti *.cmxa \
byte/*.cm[iot] byte/*.cmti \
- native/*.cm[ixt] native/*.cmti native/*.$(O) \
- $(LOCAL_SRC)/*.cm[ioaxt] $(LOCAL_SRC)/*.cmti $(LOCAL_SRC)/*.$(O)
+ native/*.cm[ixt] native/*.cmti native/*.o native/*.obj \
+ $(LOCAL_SRC)/*.cm[ioaxt] $(LOCAL_SRC)/*.cmti \
+ $(LOCAL_SRC)/*.o $(LOCAL_SRC)/*.obj
clean: partialclean
- rm -f *.$(A) *.$(O) *.so *.dll dynlink_platform_intf.mli \
+ rm -f *.a *.lib *.o *.obj *.so *.dll dynlink_platform_intf.mli \
$(LOCAL_SRC)/*.ml $(LOCAL_SRC)/*.mli $(LOCAL_SRC)/Makefile \
$(LOCAL_SRC)/.depend byte/dynlink.mli native/dynlink.mli
if priv then Symtable.hide_additions old_state;
let _, clos = Meta.reify_bytecode code events (Some digest) in
try ignore ((clos ()) : Obj.t)
- with exn -> raise (DT.Error (Library's_module_initializers_failed exn))
+ with exn ->
+ Printexc.raise_with_backtrace
+ (DT.Error (Library's_module_initializers_failed exn))
+ (Printexc.get_raw_backtrace ())
let load ~filename:file_name ~priv:_ =
let ic = open_in_bin file_name in
$(LOCAL_SRC)/.depend: $(COMPILERLIBS_COPIED_SOURCES) \
$(COMPILERLIBS_COPIED_SOURCES_INTFS) $(LOCAL_SRC)/Makefile
- $(CAMLRUN) $(ROOTDIR)/ocamlc -depend -slash -I $(LOCAL_SRC) \
+ $(BEST_OCAMLDEP) -slash -I $(LOCAL_SRC) \
$(COMPILERLIBS_COPIED_SOURCES) \
$(COMPILERLIBS_COPIED_SOURCES_INTFS) \
> $(LOCAL_SRC)/.depend
let run handle ~unit_header ~priv:_ =
List.iter (fun cu ->
try ndl_run handle cu
- with exn -> raise (DT.Error (Library's_module_initializers_failed exn)))
+ with exn ->
+ Printexc.raise_with_backtrace
+ (DT.Error (Library's_module_initializers_failed exn))
+ (Printexc.get_raw_backtrace ()))
(Unit_header.defined_symbols unit_header)
let load ~filename ~priv =
ROOTDIR=../..
-include $(ROOTDIR)/Makefile.config
-include $(ROOTDIR)/Makefile.common
+-include $(ROOTDIR)/Makefile.config
+-include $(ROOTDIR)/Makefile.common
include $(ROOTDIR)/Makefile.best_binaries
OC_CFLAGS += $(SHAREDLIB_CFLAGS)
rm -f *.cm*
clean: partialclean
- rm -f dllthreads*$(EXT_DLL) *.$(A) *.$(O)
+ rm -f dllthreads*.so dllthreads*.dll *.a *.lib *.o *.obj
INSTALL_THREADSLIBDIR=$(INSTALL_LIBDIR)/$(LIBNAME)
#include <unistd.h>
#endif
-#ifdef __GNUC__
-#define INLINE inline
-#else
-#define INLINE
-#endif
-
typedef int st_retcode;
#define SIGPREEMPTION SIGVTALRM
/* Cleanup at thread exit */
-static INLINE void st_thread_cleanup(void)
+Caml_inline void st_thread_cleanup(void)
{
return;
}
return pthread_key_create(res, NULL);
}
-static INLINE void * st_tls_get(st_tlskey k)
+Caml_inline void * st_tls_get(st_tlskey k)
{
return pthread_getspecific(k);
}
-static INLINE void st_tls_set(st_tlskey k, void * v)
+Caml_inline void st_tls_set(st_tlskey k, void * v)
{
pthread_setspecific(k, v);
}
}
CAMLno_tsan /* This can be called for reading [waiters] without locking. */
-static INLINE int st_masterlock_waiters(st_masterlock * m)
+Caml_inline int st_masterlock_waiters(st_masterlock * m)
{
return m->waiters;
}
off the lock to a waiter we know exists, it's safe, as they'll certainly
re-wake us later.
*/
-static INLINE void st_thread_yield(st_masterlock * m)
+Caml_inline void st_thread_yield(st_masterlock * m)
{
pthread_mutex_lock(&m->lock);
/* We must hold the lock to call this. */
return rc;
}
-static INLINE int st_mutex_lock(st_mutex m)
+Caml_inline int st_mutex_lock(st_mutex m)
{
return pthread_mutex_lock(m);
}
#define PREVIOUSLY_UNLOCKED 0
#define ALREADY_LOCKED EBUSY
-static INLINE int st_mutex_trylock(st_mutex m)
+Caml_inline int st_mutex_trylock(st_mutex m)
{
return pthread_mutex_trylock(m);
}
-static INLINE int st_mutex_unlock(st_mutex m)
+Caml_inline int st_mutex_unlock(st_mutex m)
{
return pthread_mutex_unlock(m);
}
return rc;
}
-static INLINE int st_condvar_signal(st_condvar c)
+Caml_inline int st_condvar_signal(st_condvar c)
{
return pthread_cond_signal(c);
}
-static INLINE int st_condvar_broadcast(st_condvar c)
+Caml_inline int st_condvar_broadcast(st_condvar c)
{
return pthread_cond_broadcast(c);
}
-static INLINE int st_condvar_wait(st_condvar c, st_mutex m)
+Caml_inline int st_condvar_wait(st_condvar c, st_mutex m)
{
return pthread_cond_wait(c, m);
}
int backtrace_pos; /* Saved Caml_state->backtrace_pos */
backtrace_slot * backtrace_buffer; /* Saved Caml_state->backtrace_buffer */
value backtrace_last_exn; /* Saved Caml_state->backtrace_last_exn (root) */
- int memprof_suspended; /* Saved caml_memprof_suspended */
+ struct caml_memprof_th_ctx memprof_ctx;
};
typedef struct caml_thread_struct * caml_thread_t;
/* Saving and restoring runtime state in curr_thread */
-static inline void caml_thread_save_runtime_state(void)
+Caml_inline void caml_thread_save_runtime_state(void)
{
#ifdef NATIVE_CODE
curr_thread->top_of_stack = Caml_state->top_of_stack;
curr_thread->backtrace_pos = Caml_state->backtrace_pos;
curr_thread->backtrace_buffer = Caml_state->backtrace_buffer;
curr_thread->backtrace_last_exn = Caml_state->backtrace_last_exn;
- curr_thread->memprof_suspended = caml_memprof_suspended;
+ caml_memprof_save_th_ctx(&curr_thread->memprof_ctx);
}
-static inline void caml_thread_restore_runtime_state(void)
+Caml_inline void caml_thread_restore_runtime_state(void)
{
#ifdef NATIVE_CODE
Caml_state->top_of_stack = curr_thread->top_of_stack;
Caml_state->backtrace_pos = curr_thread->backtrace_pos;
Caml_state->backtrace_buffer = curr_thread->backtrace_buffer;
Caml_state->backtrace_last_exn = curr_thread->backtrace_last_exn;
- caml_memprof_suspended = curr_thread->memprof_suspended;
+ caml_memprof_restore_th_ctx(&curr_thread->memprof_ctx);
}
/* Hooks for caml_enter_blocking_section and caml_leave_blocking_section */
th->backtrace_pos = 0;
th->backtrace_buffer = NULL;
th->backtrace_last_exn = Val_unit;
- th->memprof_suspended = 0;
+ caml_memprof_init_th_ctx(&th->memprof_ctx);
return th;
}
curr_thread data to make sure that the cleanup logic
below uses accurate information. */
caml_thread_save_runtime_state();
+ /* Tell memprof that this thread is terminating. */
+ caml_memprof_stop_th_ctx(&curr_thread->memprof_ctx);
/* Signal that the thread has terminated */
caml_threadstatus_terminate(Terminated(curr_thread->descr));
/* Remove th from the doubly-linked list of threads and free its info block */
#include <caml/osdeps.h>
-#define INLINE __inline
-
#if 1
#define TRACE(x)
#define TRACE1(x,y)
return 0;
}
-static INLINE void * st_tls_get(st_tlskey k)
+Caml_inline void * st_tls_get(st_tlskey k)
{
return TlsGetValue(k);
}
-static INLINE void st_tls_set(st_tlskey k, void * v)
+Caml_inline void st_tls_set(st_tlskey k, void * v)
{
TlsSetValue(k, v);
}
EnterCriticalSection(m);
}
-static INLINE void st_masterlock_acquire(st_masterlock * m)
+Caml_inline void st_masterlock_acquire(st_masterlock * m)
{
TRACE("st_masterlock_acquire");
EnterCriticalSection(m);
TRACE("st_masterlock_acquire (done)");
}
-static INLINE void st_masterlock_release(st_masterlock * m)
+Caml_inline void st_masterlock_release(st_masterlock * m)
{
LeaveCriticalSection(m);
TRACE("st_masterlock_released");
}
-static INLINE int st_masterlock_waiters(st_masterlock * m)
+Caml_inline int st_masterlock_waiters(st_masterlock * m)
{
return 1; /* info not maintained */
}
/* Scheduling hints */
-static INLINE void st_thread_yield(st_masterlock * m)
+Caml_inline void st_thread_yield(st_masterlock * m)
{
LeaveCriticalSection(m);
Sleep(0);
return 0;
}
-static INLINE DWORD st_mutex_lock(st_mutex m)
+Caml_inline DWORD st_mutex_lock(st_mutex m)
{
TRACE1("st_mutex_lock", m);
EnterCriticalSection(m);
#define PREVIOUSLY_UNLOCKED 0
#define ALREADY_LOCKED (1<<29)
-static INLINE DWORD st_mutex_trylock(st_mutex m)
+Caml_inline DWORD st_mutex_trylock(st_mutex m)
{
TRACE1("st_mutex_trylock", m);
if (TryEnterCriticalSection(m)) {
}
}
-static INLINE DWORD st_mutex_unlock(st_mutex m)
+Caml_inline DWORD st_mutex_unlock(st_mutex m)
{
TRACE1("st_mutex_unlock", m);
LeaveCriticalSection(m);
../../runtime/caml/m.h ../../runtime/caml/s.h ../../runtime/caml/misc.h \
../../runtime/caml/domain_state.h ../../runtime/caml/mlvalues.h \
../../runtime/caml/domain_state.tbl ../../runtime/caml/debugger.h \
- unixsupport.h
+ ../../runtime/caml/eventlog.h unixsupport.h
fsync.o: fsync.c ../../runtime/caml/mlvalues.h \
../../runtime/caml/config.h ../../runtime/caml/m.h \
../../runtime/caml/s.h ../../runtime/caml/misc.h \
#include <caml/mlvalues.h>
#include <caml/debugger.h>
+#include <caml/eventlog.h>
#include "unixsupport.h"
CAMLprim value unix_fork(value unit)
{
int ret;
+
+ CAML_EV_FLUSH();
+
ret = fork();
if (ret == -1) uerror("fork", Nothing);
+
+ CAML_EVENTLOG_DO({
+ if (ret == 0)
+ caml_eventlog_disable();
+ });
+
if (caml_debugger_in_use)
if ((caml_debugger_fork_mode && ret == 0) ||
(!caml_debugger_fork_mode && ret != 0))
caml_debugger_cleanup_fork();
+
return Val_int(ret);
}
#define CAML_INTERNALS
#include <errno.h>
+#include <math.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <caml/mlvalues.h>
S_IFREG, S_IFDIR, S_IFCHR, S_IFBLK, S_IFLNK, S_IFIFO, S_IFSOCK
};
+/* Transform a (seconds, nanoseconds) time stamp (in the style of
+ struct timespec) to a number of seconds in floating-point.
+ Make sure the integer part of the result is always equal to [seconds]
+ (issue #9490). */
+
+static double stat_timestamp(time_t sec, long nsec)
+{
+ /* The conversion of sec to FP is exact for the foreseeable future.
+ (It starts rounding when sec > 2^53, i.e. in 285 million years.) */
+ double s = (double) sec;
+ /* The conversion of nsec to fraction of seconds can round.
+ Still, we have 0 <= n < 1.0. */
+ double n = (double) nsec / 1e9;
+ /* The sum s + n can round up, hence s <= t + <= s + 1.0 */
+ double t = s + n;
+ /* Detect the "round up to s + 1" case and decrease t so that
+ its integer part is s. */
+ if (t == s + 1.0) t = nextafter(t, s);
+ return t;
+}
+
static value stat_aux(int use_64, struct stat *buf)
{
CAMLparam0();
CAMLlocal5(atime, mtime, ctime, offset, v);
#include "nanosecond_stat.h"
- atime = caml_copy_double((double) buf->st_atime
- + (NSEC(buf, a) / 1000000000.0));
- mtime = caml_copy_double((double) buf->st_mtime
- + (NSEC(buf, m) / 1000000000.0));
- ctime = caml_copy_double((double) buf->st_ctime
- + (NSEC(buf, c) / 1000000000.0));
+ atime = caml_copy_double(stat_timestamp(buf->st_atime, NSEC(buf, a)));
+ mtime = caml_copy_double(stat_timestamp(buf->st_mtime, NSEC(buf, m)));
+ ctime = caml_copy_double(stat_timestamp(buf->st_ctime, NSEC(buf, c)));
#undef NSEC
offset = use_64 ? Val_file_offset(buf->st_size) : Val_int (buf->st_size);
v = caml_alloc_small(12, 0);
its termination status. The string is interpreted by the shell
[/bin/sh] (or the command interpreter [cmd.exe] on Windows) and
therefore can contain redirections, quotes, variables, etc.
- To properly quote whitespace and shell special characters occuring
+ To properly quote whitespace and shell special characters occurring
in file names or command arguments, the use of
{!Filename.quote_command} is recommended.
The result [WEXITED 127] indicates that the shell couldn't be
type sockaddr =
ADDR_UNIX of string
- | ADDR_INET of inet_addr * int
+ | ADDR_INET of inet_addr * int (**)
(** The type of socket addresses. [ADDR_UNIX name] is a socket
address in the Unix domain; [name] is a file name in the file
system. [ADDR_INET(addr,port)] is a socket address in the Internet
type msg_flag =
MSG_OOB
| MSG_DONTROUTE
- | MSG_PEEK
+ | MSG_PEEK (**)
(** The flags for {!Unix.recv}, {!Unix.recvfrom},
{!Unix.send} and {!Unix.sendto}. *)
type sockaddr = Unix.sockaddr =
ADDR_UNIX of string
- | ADDR_INET of inet_addr * int
+ | ADDR_INET of inet_addr * int (**)
(** The type of socket addresses. [ADDR_UNIX name] is a socket
address in the Unix domain; [name] is a file name in the file
system. [ADDR_INET(addr,port)] is a socket address in the Internet
type msg_flag = Unix.msg_flag =
MSG_OOB
| MSG_DONTROUTE
- | MSG_PEEK
+ | MSG_PEEK (**)
(** The flags for {!UnixLabels.recv}, {!UnixLabels.recvfrom},
{!UnixLabels.send} and {!UnixLabels.sendto}. *)
#define CAML_INTERNALS
#include <errno.h>
+#ifdef _MSC_VER
+#include <float.h>
+#ifndef nextafter
+#define nextafter _nextafter
+#endif
+#else
+#include <math.h>
+#endif
#include <caml/mlvalues.h>
#include <caml/memory.h>
#include <caml/alloc.h>
S_IFREG, S_IFDIR, S_IFCHR, S_IFBLK, S_IFLNK, S_IFIFO, S_IFSOCK
};
+/* Transform a timestamp expressed in units of 100ns
+ to a number of seconds in floating-point.
+ Make sure the integer part of the result is always equal to
+ the timestamp divided by 10^7 (issue #9490).
+ Use the same algorithm as for the Unix implementation
+ (in ../unix/stat.c) in the hope of getting the same result
+ when the same file is accessed either from Windows or from Linux.
+ */
+
+static double stat_timestamp(__time64_t tm)
+{
+ /* Split the timestamp into seconds and remaining 100ns units */
+ __int64 sec = tm / 10000000; /* 10^7 */
+ int n100sec = tm % 10000000;
+ /* The conversion of sec to FP is exact for the foreseeable future.
+ (It starts rounding when sec > 2^53, i.e. in 285 million years.) */
+ double s = (double) sec;
+ /* The conversion of n100sec to fraction of seconds can round.
+ Still, we have 0 <= n100sec < 1.0. */
+ double n = (double) n100sec / 1e7;
+ /* The sum s + n can round up, hence s <= t + <= s + 1.0 */
+ double t = s + n;
+ /* Detect the "round up to s + 1" case and decrease t so that
+ its integer part is s. */
+ if (t == s + 1.0) t = nextafter(t, s);
+ return t;
+}
+
static value stat_aux(int use_64, __int64 st_ino, struct _stat64 *buf)
{
CAMLparam0 ();
Store_field (v, 7, Val_int (buf->st_rdev));
Store_field (v, 8,
use_64 ? caml_copy_int64(buf->st_size) : Val_int (buf->st_size));
- Store_field (v, 9, caml_copy_double((double) buf->st_atime / 10000000.0));
- Store_field (v, 10, caml_copy_double((double) buf->st_mtime / 10000000.0));
- Store_field (v, 11, caml_copy_double((double) buf->st_ctime / 10000000.0));
+ Store_field (v, 9, caml_copy_double(stat_timestamp(buf->st_atime)));
+ Store_field (v, 10, caml_copy_double(stat_timestamp(buf->st_mtime)));
+ Store_field (v, 11, caml_copy_double(stat_timestamp(buf->st_ctime)));
CAMLreturn (v);
}
external error_message : error -> string = "unix_error_message"
+let () =
+ Printexc.register_printer
+ (function
+ | Unix_error (e, s, s') ->
+ let msg = match e with
+ | E2BIG -> "E2BIG"
+ | EACCES -> "EACCES"
+ | EAGAIN -> "EAGAIN"
+ | EBADF -> "EBADF"
+ | EBUSY -> "EBUSY"
+ | ECHILD -> "ECHILD"
+ | EDEADLK -> "EDEADLK"
+ | EDOM -> "EDOM"
+ | EEXIST -> "EEXIST"
+ | EFAULT -> "EFAULT"
+ | EFBIG -> "EFBIG"
+ | EINTR -> "EINTR"
+ | EINVAL -> "EINVAL"
+ | EIO -> "EIO"
+ | EISDIR -> "EISDIR"
+ | EMFILE -> "EMFILE"
+ | EMLINK -> "EMLINK"
+ | ENAMETOOLONG -> "ENAMETOOLONG"
+ | ENFILE -> "ENFILE"
+ | ENODEV -> "ENODEV"
+ | ENOENT -> "ENOENT"
+ | ENOEXEC -> "ENOEXEC"
+ | ENOLCK -> "ENOLCK"
+ | ENOMEM -> "ENOMEM"
+ | ENOSPC -> "ENOSPC"
+ | ENOSYS -> "ENOSYS"
+ | ENOTDIR -> "ENOTDIR"
+ | ENOTEMPTY -> "ENOTEMPTY"
+ | ENOTTY -> "ENOTTY"
+ | ENXIO -> "ENXIO"
+ | EPERM -> "EPERM"
+ | EPIPE -> "EPIPE"
+ | ERANGE -> "ERANGE"
+ | EROFS -> "EROFS"
+ | ESPIPE -> "ESPIPE"
+ | ESRCH -> "ESRCH"
+ | EXDEV -> "EXDEV"
+ | EWOULDBLOCK -> "EWOULDBLOCK"
+ | EINPROGRESS -> "EINPROGRESS"
+ | EALREADY -> "EALREADY"
+ | ENOTSOCK -> "ENOTSOCK"
+ | EDESTADDRREQ -> "EDESTADDRREQ"
+ | EMSGSIZE -> "EMSGSIZE"
+ | EPROTOTYPE -> "EPROTOTYPE"
+ | ENOPROTOOPT -> "ENOPROTOOPT"
+ | EPROTONOSUPPORT -> "EPROTONOSUPPORT"
+ | ESOCKTNOSUPPORT -> "ESOCKTNOSUPPORT"
+ | EOPNOTSUPP -> "EOPNOTSUPP"
+ | EPFNOSUPPORT -> "EPFNOSUPPORT"
+ | EAFNOSUPPORT -> "EAFNOSUPPORT"
+ | EADDRINUSE -> "EADDRINUSE"
+ | EADDRNOTAVAIL -> "EADDRNOTAVAIL"
+ | ENETDOWN -> "ENETDOWN"
+ | ENETUNREACH -> "ENETUNREACH"
+ | ENETRESET -> "ENETRESET"
+ | ECONNABORTED -> "ECONNABORTED"
+ | ECONNRESET -> "ECONNRESET"
+ | ENOBUFS -> "ENOBUFS"
+ | EISCONN -> "EISCONN"
+ | ENOTCONN -> "ENOTCONN"
+ | ESHUTDOWN -> "ESHUTDOWN"
+ | ETOOMANYREFS -> "ETOOMANYREFS"
+ | ETIMEDOUT -> "ETIMEDOUT"
+ | ECONNREFUSED -> "ECONNREFUSED"
+ | EHOSTDOWN -> "EHOSTDOWN"
+ | EHOSTUNREACH -> "EHOSTUNREACH"
+ | ELOOP -> "ELOOP"
+ | EOVERFLOW -> "EOVERFLOW"
+ | EUNKNOWNERR x -> Printf.sprintf "EUNKNOWNERR %d" x in
+ Some (Printf.sprintf "Unix.Unix_error(Unix.%s, %S, %S)" msg s s')
+ | _ -> None)
+
let handle_unix_error f arg =
try
f arg
type file_descr
-external execv : string -> string array -> 'a = "unix_execv"
-external execve : string -> string array -> string array -> 'a = "unix_execve"
-external execvp : string -> string array -> 'a = "unix_execvp"
-external execvpe : string -> string array -> string array -> 'a = "unix_execvpe"
+let maybe_quote f =
+ if String.contains f ' ' ||
+ String.contains f '\"' ||
+ String.contains f '\t' ||
+ f = ""
+ then Filename.quote f
+ else f
+
+external sys_execv : string -> string array -> 'a = "unix_execv"
+external sys_execve :
+ string -> string array -> string array -> 'a = "unix_execve"
+external sys_execvp : string -> string array -> 'a = "unix_execvp"
+external sys_execvpe :
+ string -> string array -> string array -> 'a = "unix_execvpe"
+
+let execv prog args =
+ sys_execv prog (Array.map maybe_quote args)
+let execve prog args env =
+ sys_execve prog (Array.map maybe_quote args) env
+let execvp prog args =
+ sys_execvp prog (Array.map maybe_quote args)
+let execvpe prog args env =
+ sys_execvpe prog (Array.map maybe_quote args) env
external waitpid : wait_flag list -> int -> int * process_status
= "win_waitpid"
= "win_create_process" "win_create_process_native"
let make_cmdline args =
- let maybe_quote f =
- if String.contains f ' ' ||
- String.contains f '\"' ||
- String.contains f '\t' ||
- f = ""
- then Filename.quote f
- else f in
String.concat " " (List.map maybe_quote (Array.to_list args))
let make_process_env env =
let nativeint ?(suffix='n') i = integer ~suffix (Nativeint.to_string i)
let float ?suffix f = Pconst_float (f, suffix)
let char c = Pconst_char c
- let string ?quotation_delimiter s = Pconst_string (s, quotation_delimiter)
+ let string ?quotation_delimiter ?(loc= !default_loc) s =
+ Pconst_string (s, loc, quotation_delimiter)
end
module Attr = struct
module Const : sig
val char : char -> constant
- val string : ?quotation_delimiter:string -> string -> constant
+ val string :
+ ?quotation_delimiter:string -> ?loc:Location.t -> string -> constant
val integer : ?suffix:char -> string -> constant
val int : ?suffix:char -> int -> constant
val int32 : ?suffix:char -> int32 -> constant
let loc = ty.ptyp_loc in
match ty.ptyp_desc with
| Ptyp_tuple ([] | [_]) -> invalid_tuple loc
- | Ptyp_class (id, _) -> simple_longident id
| Ptyp_package (_, cstrs) ->
List.iter (fun (id, _) -> simple_longident id) cstrs
| _ -> ()
class_type_declaration: mapper -> class_type_declaration
-> class_type_declaration;
class_type_field: mapper -> class_type_field -> class_type_field;
+ constant: mapper -> constant -> constant;
constructor_declaration: mapper -> constructor_declaration
-> constructor_declaration;
expr: mapper -> expression -> expression;
let map_loc sub {loc; txt} = {loc = sub.location sub loc; txt}
+module C = struct
+ (* Constants *)
+
+ let map sub c = match c with
+ | Pconst_integer _
+ | Pconst_char _
+ | Pconst_float _
+ -> c
+ | Pconst_string (s, loc, quotation_delimiter) ->
+ let loc = sub.location sub loc in
+ Const.string ~loc ?quotation_delimiter s
+end
+
module T = struct
(* Type expressions for the core language *)
let attrs = sub.attributes sub attrs in
match desc with
| Pexp_ident x -> ident ~loc ~attrs (map_loc sub x)
- | Pexp_constant x -> constant ~loc ~attrs x
+ | Pexp_constant x -> constant ~loc ~attrs (sub.constant sub x)
| Pexp_let (r, vbs, e) ->
let_ ~loc ~attrs r (List.map (sub.value_binding sub) vbs)
(sub.expr sub e)
| Ppat_any -> any ~loc ~attrs ()
| Ppat_var s -> var ~loc ~attrs (map_loc sub s)
| Ppat_alias (p, s) -> alias ~loc ~attrs (sub.pat sub p) (map_loc sub s)
- | Ppat_constant c -> constant ~loc ~attrs c
+ | Ppat_constant c -> constant ~loc ~attrs (sub.constant sub c)
| Ppat_interval (c1, c2) -> interval ~loc ~attrs c1 c2
| Ppat_tuple pl -> tuple ~loc ~attrs (List.map (sub.pat sub) pl)
| Ppat_construct (l, p) ->
let default_mapper =
{
+ constant = C.map;
structure = (fun this l -> List.map (this.structure_item this) l);
structure_item = M.map_structure_item;
module_expr = M.map;
let str_of_pp pp_msg = Format.asprintf "%t" pp_msg in
let extension_of_sub sub =
{ loc = sub.loc; txt = "ocaml.error" },
- PStr ([Str.eval (Exp.constant (Pconst_string (str_of_pp sub.txt, None)))])
+ PStr ([Str.eval (Exp.constant
+ (Pconst_string (str_of_pp sub.txt, sub.loc, None)))])
in
{ loc = main.loc; txt = "ocaml.error" },
- PStr (Str.eval (Exp.constant (Pconst_string (str_of_pp main.txt, None))) ::
+ PStr (Str.eval (Exp.constant
+ (Pconst_string (str_of_pp main.txt, main.loc, None))) ::
List.map (fun msg -> Str.extension (extension_of_sub msg)) sub)
let attribute_of_warning loc s =
Attr.mk
{loc; txt = "ocaml.ppwarning" }
- (PStr ([Str.eval ~loc (Exp.constant (Pconst_string (s, None)))]))
+ (PStr ([Str.eval ~loc (Exp.constant (Pconst_string (s, loc, None)))]))
let cookies = ref String.Map.empty
let lid name = { txt = Lident name; loc = Location.none }
- let make_string x = Exp.constant (Pconst_string (x, None))
+ let make_string s = Exp.constant (Const.string s)
let make_bool x =
if x
let restore fields =
let field name payload =
let rec get_string = function
- | { pexp_desc = Pexp_constant (Pconst_string (str, None)) } -> str
+ | { pexp_desc = Pexp_constant (Pconst_string (str, _, None)) } -> str
| _ -> raise_errorf "Internal error: invalid [@@@ocaml.ppx.context \
{ %s }] string syntax" name
and get_bool pexp =
class_type_declaration: mapper -> class_type_declaration
-> class_type_declaration;
class_type_field: mapper -> class_type_field -> class_type_field;
+ constant: mapper -> constant -> constant;
constructor_declaration: mapper -> constructor_declaration
-> constructor_declaration;
expr: mapper -> expression -> expression;
type constant =
Const_int of int
| Const_char of char
- | Const_string of string * string option
+ | Const_string of string * Location.t * string option
| Const_float of string
| Const_int32 of int32
| Const_int64 of int64
open Parsetree
let string_of_cst = function
- | Pconst_string(s, _) -> Some s
+ | Pconst_string(s, _, _) -> Some s
| _ -> None
let string_of_payload = function
(({txt = ("ocaml.error"|"error"); loc}, p), _)} ->
begin match p with
| PStr([{pstr_desc=Pstr_eval
- ({pexp_desc=Pexp_constant(Pconst_string(msg,_))}, _)}]) ->
+ ({pexp_desc=Pexp_constant(Pconst_string(msg,_,_))}, _)}
+ ]) ->
{ Location.loc; txt = fun ppf -> Format.pp_print_text ppf msg }
| _ ->
{ Location.loc; txt = fun ppf ->
begin match p with
| PStr [] -> raise Location.Already_displayed_error
| PStr({pstr_desc=Pstr_eval
- ({pexp_desc=Pexp_constant(Pconst_string(msg,_))}, _)}::
+ ({pexp_desc=Pexp_constant(Pconst_string(msg,_,_))}, _)}::
inner) ->
let sub = List.map (submessage_from loc txt) inner in
Location.error_of_printer ~loc ~sub Format.pp_print_text msg
Pstr_eval
({pexp_desc=Pexp_apply
({pexp_desc=Pexp_ident{txt=Longident.Lident id}},
- [Nolabel,{pexp_desc=Pexp_constant (Pconst_string(s,_))}])
+ [Nolabel,{pexp_desc=Pexp_constant (Pconst_string(s,_,_))}])
},_)}] ->
Some (id, s)
| PStr[
let process_alert loc txt = function
| PStr[{pstr_desc=
Pstr_eval(
- {pexp_desc=Pexp_constant(Pconst_string(s,_))},
+ {pexp_desc=Pexp_constant(Pconst_string(s,_,_))},
_)
}] ->
begin try Warnings.parse_alert_option s
attr_payload =
PStr [
{ pstr_desc=
- Pstr_eval({pexp_desc=Pexp_constant (Pconst_string (s, _))},_);
+ Pstr_eval({pexp_desc=Pexp_constant (Pconst_string (s, _, _))},_);
pstr_loc }
];
} when ppwarning ->
let docs_attr ds =
let open Parsetree in
+ let body = ds.ds_body in
+ let loc = ds.ds_loc in
let exp =
- { pexp_desc = Pexp_constant (Pconst_string(ds.ds_body, None));
- pexp_loc = ds.ds_loc;
+ { pexp_desc = Pexp_constant (Pconst_string(body, loc, None));
+ pexp_loc = loc;
pexp_loc_stack = [];
pexp_attributes = []; }
in
let item =
- { pstr_desc = Pstr_eval (exp, []); pstr_loc = exp.pexp_loc }
+ { pstr_desc = Pstr_eval (exp, []); pstr_loc = loc }
in
{ attr_name = doc_loc;
attr_payload = PStr [item];
- attr_loc = Location.none }
+ attr_loc = loc }
let add_docs_attrs docs attrs =
let attrs =
let text_attr ds =
let open Parsetree in
+ let body = ds.ds_body in
+ let loc = ds.ds_loc in
let exp =
- { pexp_desc = Pexp_constant (Pconst_string(ds.ds_body, None));
- pexp_loc = ds.ds_loc;
+ { pexp_desc = Pexp_constant (Pconst_string(body, loc, None));
+ pexp_loc = loc;
pexp_loc_stack = [];
pexp_attributes = []; }
in
let item =
- { pstr_desc = Pstr_eval (exp, []); pstr_loc = exp.pexp_loc }
+ { pstr_desc = Pstr_eval (exp, []); pstr_loc = loc }
in
{ attr_name = text_loc;
attr_payload = PStr [item];
- attr_loc = Location.none }
+ attr_loc = loc }
let add_text_attrs dsl attrs =
let fdsl = List.filter (function {ds_body=""} -> false| _ ->true) dsl in
let store_escaped_uchar lexbuf u =
if in_comment () then store_lexeme lexbuf else store_string_utf_8_uchar u
-let with_comment_buffer comment lexbuf =
+let compute_quoted_string_idloc {Location.loc_start = orig_loc } shift id =
+ let id_start_pos = orig_loc.Lexing.pos_cnum + shift in
+ let loc_start =
+ Lexing.{orig_loc with pos_cnum = id_start_pos }
+ in
+ let loc_end =
+ Lexing.{orig_loc with pos_cnum = id_start_pos + String.length id}
+ in
+ {Location. loc_start ; loc_end ; loc_ghost = false }
+
+let wrap_string_lexer f lexbuf =
+ let loc_start = lexbuf.lex_curr_p in
+ reset_string_buffer();
+ is_in_string := true;
+ let string_start = lexbuf.lex_start_p in
+ string_start_loc := Location.curr lexbuf;
+ let loc_end = f lexbuf in
+ is_in_string := false;
+ lexbuf.lex_start_p <- string_start;
+ let loc = Location.{loc_ghost= false; loc_start; loc_end} in
+ get_stored_string (), loc
+
+let wrap_comment_lexer comment lexbuf =
let start_loc = Location.curr lexbuf in
comment_start_loc := [start_loc];
reset_string_buffer ();
let end_loc = comment lexbuf in
let s = get_stored_string () in
reset_string_buffer ();
- let loc = { start_loc with Location.loc_end = end_loc.Location.loc_end } in
- s, loc
+ s,
+ { start_loc with Location.loc_end = end_loc.Location.loc_end }
let error lexbuf e = raise (Error(e, Location.curr lexbuf))
let error_loc loc e = raise (Error(e, loc))
let kwdopchar =
['$' '&' '*' '+' '-' '/' '<' '=' '>' '@' '^' '|']
+let ident = (lowercase | uppercase) identchar*
+let extattrident = ident ('.' ident)*
+
let decimal_literal =
['0'-'9'] ['0'-'9' '_']*
let hex_digit =
| (float_literal | hex_float_literal | int_literal) identchar+ as invalid
{ error lexbuf (Invalid_literal invalid) }
| "\""
- { reset_string_buffer();
- is_in_string := true;
- let string_start = lexbuf.lex_start_p in
- string_start_loc := Location.curr lexbuf;
- string lexbuf;
- is_in_string := false;
- lexbuf.lex_start_p <- string_start;
- STRING (get_stored_string(), None) }
+ { let s, loc = wrap_string_lexer string lexbuf in
+ STRING (s, loc, None) }
| "{" (lowercase* as delim) "|"
- { reset_string_buffer();
- is_in_string := true;
- let string_start = lexbuf.lex_start_p in
- string_start_loc := Location.curr lexbuf;
- quoted_string delim lexbuf;
- is_in_string := false;
- lexbuf.lex_start_p <- string_start;
- STRING (get_stored_string(), Some delim) }
+ { let s, loc = wrap_string_lexer (quoted_string delim) lexbuf in
+ STRING (s, loc, Some delim) }
+ | "{%" (extattrident as id) "|"
+ { let orig_loc = Location.curr lexbuf in
+ let s, loc = wrap_string_lexer (quoted_string "") lexbuf in
+ let idloc = compute_quoted_string_idloc orig_loc 2 id in
+ QUOTED_STRING_EXPR (id, idloc, s, loc, Some "") }
+ | "{%" (extattrident as id) blank+ (lowercase* as delim) "|"
+ { let orig_loc = Location.curr lexbuf in
+ let s, loc = wrap_string_lexer (quoted_string delim) lexbuf in
+ let idloc = compute_quoted_string_idloc orig_loc 2 id in
+ QUOTED_STRING_EXPR (id, idloc, s, loc, Some delim) }
+ | "{%%" (extattrident as id) "|"
+ { let orig_loc = Location.curr lexbuf in
+ let s, loc = wrap_string_lexer (quoted_string "") lexbuf in
+ let idloc = compute_quoted_string_idloc orig_loc 3 id in
+ QUOTED_STRING_ITEM (id, idloc, s, loc, Some "") }
+ | "{%%" (extattrident as id) blank+ (lowercase* as delim) "|"
+ { let orig_loc = Location.curr lexbuf in
+ let s, loc = wrap_string_lexer (quoted_string delim) lexbuf in
+ let idloc = compute_quoted_string_idloc orig_loc 3 id in
+ QUOTED_STRING_ITEM (id, idloc, s, loc, Some delim) }
| "\'" newline "\'"
{ update_loc lexbuf None 1 false 1;
(* newline is ('\013'* '\010') *)
| "\'" ("\\" _ as esc)
{ error lexbuf (Illegal_escape (esc, None)) }
| "(*"
- { let s, loc = with_comment_buffer comment lexbuf in
+ { let s, loc = wrap_comment_lexer comment lexbuf in
COMMENT (s, loc) }
| "(**"
- { let s, loc = with_comment_buffer comment lexbuf in
+ { let s, loc = wrap_comment_lexer comment lexbuf in
if !handle_docstrings then
DOCSTRING (Docstrings.docstring s loc)
else
}
| "(**" (('*'+) as stars)
{ let s, loc =
- with_comment_buffer
+ wrap_comment_lexer
(fun lexbuf ->
store_string ("*" ^ stars);
comment lexbuf)
| "(*)"
{ if !print_warnings then
Location.prerr_warning (Location.curr lexbuf) Warnings.Comment_start;
- let s, loc = with_comment_buffer comment lexbuf in
+ let s, loc = wrap_comment_lexer comment lexbuf in
COMMENT (s, loc) }
| "(*" (('*'*) as stars) "*)"
{ if !handle_docstrings && stars="" then
string_start_loc := Location.curr lexbuf;
store_string_char '\"';
is_in_string := true;
- begin try string lexbuf
+ let _loc = try string lexbuf
with Error (Unterminated_string, str_start) ->
match !comment_start_loc with
| [] -> assert false
let start = List.hd (List.rev !comment_start_loc) in
comment_start_loc := [];
error_loc loc (Unterminated_string_in_comment (start, str_start))
- end;
+ in
is_in_string := false;
store_string_char '\"';
comment lexbuf }
- | "{" (lowercase* as delim) "|"
+ | "{" ('%' '%'? extattrident blank*)? (lowercase* as delim) "|"
{
string_start_loc := Location.curr lexbuf;
store_lexeme lexbuf;
is_in_string := true;
- begin try quoted_string delim lexbuf
+ let _loc = try quoted_string delim lexbuf
with Error (Unterminated_string, str_start) ->
match !comment_start_loc with
| [] -> assert false
let start = List.hd (List.rev !comment_start_loc) in
comment_start_loc := [];
error_loc loc (Unterminated_string_in_comment (start, str_start))
- end;
+ in
is_in_string := false;
store_string_char '|';
store_string delim;
store_string_char '}';
comment lexbuf }
-
| "\'\'"
{ store_lexeme lexbuf; comment lexbuf }
| "\'" newline "\'"
store_lexeme lexbuf;
comment lexbuf
}
- | (lowercase | uppercase) identchar *
+ | ident
{ store_lexeme lexbuf; comment lexbuf }
| _
{ store_lexeme lexbuf; comment lexbuf }
and string = parse
'\"'
- { () }
+ { lexbuf.lex_start_p }
| '\\' newline ([' ' '\t'] * as space)
{ update_loc lexbuf None 1 false (String.length space);
if in_comment () then store_lexeme lexbuf;
error_loc !string_start_loc Unterminated_string }
| "|" (lowercase* as edelim) "}"
{
- if delim = edelim then ()
+ if delim = edelim then lexbuf.lex_start_p
else (store_lexeme lexbuf; quoted_string delim lexbuf)
}
| (_ as c)
;;
let none = in_file "_none_";;
+let is_none l = (l = none);;
let curr lexbuf = {
loc_start = lexbuf.lex_start_p;
val none : t
(** An arbitrary value of type [t]; describes an empty ghost range. *)
+val is_none : t -> bool
+(** True for [Location.none], false any other location *)
+
val in_file : string -> t
(** Return an empty ghost range located in a given file. *)
| Ldot(_, s) -> s
| Lapply(_, _) -> Misc.fatal_error "Longident.last"
+
let rec split_at_dots s pos =
try
let dot = String.index_from s pos '.' in
val flatten: t -> string list
val unflatten: string list -> t option
+(** For a non-empty list [l], [unflatten l] is [Some lid] where [lid] is
+ the long identifier created by concatenating the elements of [l]
+ with [Ldot].
+ [unflatten []] is [None].
+*)
+
val last: t -> string
val parse: string -> t
+[@@deprecated "this function may misparse its input,\n\
+use \"Parse.longident\" or \"Longident.unflatten\""]
+(**
+
+ This function is broken on identifiers that are not just "Word.Word.word";
+ for example, it returns incorrect results on infix operators
+ and extended module paths.
+
+ If you want to generate long identifiers that are a list of
+ dot-separated identifiers, the function {!unflatten} is safer and faster.
+ {!unflatten} is available since OCaml 4.06.0.
+
+ If you want to parse any identifier correctly, use the long-identifiers
+ functions from the {!Parse} module, in particular {!Parse.longident}.
+ They are available since OCaml 4.11, and also provide proper
+ input-location support.
+
+*)
+
+
(** To print a longident, see {!Pprintast.longident}, using
{!Format.asprintf} to convert to a string. *)
and expression = wrap_menhir Parser.Incremental.parse_expression
and pattern = wrap_menhir Parser.Incremental.parse_pattern
-
+let longident = wrap_menhir Parser.Incremental.parse_any_longident
+let val_ident = wrap_menhir Parser.Incremental.parse_val_longident
+let constr_ident= wrap_menhir Parser.Incremental.parse_constr_longident
+let extended_module_path =
+ wrap_menhir Parser.Incremental.parse_mod_ext_longident
+let simple_module_path = wrap_menhir Parser.Incremental.parse_mod_longident
+let type_ident = wrap_menhir Parser.Incremental.parse_mty_longident
(* Error reporting for Syntaxerr *)
(* The code has been moved here so that one can reuse Pprintast.tyvar *)
val core_type : Lexing.lexbuf -> Parsetree.core_type
val expression : Lexing.lexbuf -> Parsetree.expression
val pattern : Lexing.lexbuf -> Parsetree.pattern
+
+(** The functions below can be used to parse Longident safely. *)
+
+val longident: Lexing.lexbuf -> Longident.t
+(**
+ The function [longident] is guaranted to parse all subclasses
+ of {!Longident.t} used in OCaml: values, constructors, simple or extended
+ module paths, and types or module types.
+
+ However, this function accepts inputs which are not accepted by the
+ compiler, because they combine functor applications and infix operators.
+ In valid OCaml syntax, only value-level identifiers may end with infix
+ operators [Foo.( + )].
+ Moreover, in value-level identifiers the module path [Foo] must be simple
+ ([M.N] rather than [F(X)]): functor applications may only appear in
+ type-level identifiers.
+ As a consequence, a path such as [F(X).( + )] is not a valid OCaml
+ identifier; but it is accepted by this function.
+*)
+
+(** The next functions are specialized to a subclass of {!Longident.t} *)
+
+val val_ident: Lexing.lexbuf -> Longident.t
+(**
+ This function parses a syntactically valid path for a value. For instance,
+ [x], [M.x], and [(+.)] are valid. Contrarily, [M.A], [F(X).x], and [true]
+ are rejected.
+
+ Longident for OCaml's value cannot contain functor application.
+ The last component of the {!Longident.t} is not capitalized,
+ but can be an operator [A.Path.To.(.%.%.(;..)<-)]
+*)
+
+val constr_ident: Lexing.lexbuf -> Longident.t
+(**
+ This function parses a syntactically valid path for a variant constructor.
+ For instance, [A], [M.A] and [M.(::)] are valid, but both [M.a]
+ and [F(X).A] are rejected.
+
+ Longident for OCaml's variant constructors cannot contain functor
+ application.
+ The last component of the {!Longident.t} is capitalized,
+ or it may be one the special constructors: [true],[false],[()],[[]],[(::)].
+ Among those special constructors, only [(::)] can be prefixed by a module
+ path ([A.B.C.(::)]).
+*)
+
+
+val simple_module_path: Lexing.lexbuf -> Longident.t
+(**
+ This function parses a syntactically valid path for a module.
+ For instance, [A], and [M.A] are valid, but both [M.a]
+ and [F(X).A] are rejected.
+
+ Longident for OCaml's module cannot contain functor application.
+ The last component of the {!Longident.t} is capitalized.
+*)
+
+
+val extended_module_path: Lexing.lexbuf -> Longident.t
+(**
+ This function parse syntactically valid path for an extended module.
+ For instance, [A.B] and [F(A).B] are valid. Contrarily,
+ [(.%())] or [[]] are both rejected.
+
+ The last component of the {!Longident.t} is capitalized.
+
+*)
+
+val type_ident: Lexing.lexbuf -> Longident.t
+(**
+ This function parse syntactically valid path for a type or a module type.
+ For instance, [A], [t], [M.t] and [F(X).t] are valid. Contrarily,
+ [(.%())] or [[]] are both rejected.
+
+ In path for type and module types, only operators and special constructors
+ are rejected.
+
+*)
let wrap_mksig_ext ~loc (item, ext) =
wrap_sig_ext ~loc (mksig ~loc item) ext
+let mk_quotedext ~loc (id, idloc, str, strloc, delim) =
+ let exp_id = mkloc id idloc in
+ let e = ghexp ~loc (Pexp_constant (Pconst_string (str, strloc, delim))) in
+ (exp_id, PStr [mkstrexp e []])
+
let text_str pos = Str.text (rhs_text pos)
let text_sig pos = Sig.text (rhs_text pos)
let text_cstr pos = Cf.text (rhs_text pos)
%token <string> HASHOP
%token SIG
%token STAR
-%token <string * string option> STRING
+%token <string * Location.t * string option> STRING
+%token
+ <string * Location.t * string * Location.t * string option> QUOTED_STRING_EXPR
+%token
+ <string * Location.t * string * Location.t * string option> QUOTED_STRING_ITEM
%token STRUCT
%token THEN
%token TILDE
%nonassoc BACKQUOTE BANG BEGIN CHAR FALSE FLOAT INT
LBRACE LBRACELESS LBRACKET LBRACKETBAR LIDENT LPAREN
NEW PREFIXOP STRING TRUE UIDENT
- LBRACKETPERCENT
+ LBRACKETPERCENT QUOTED_STRING_EXPR
/* Entry points */
%type <Parsetree.expression> parse_expression
%start parse_pattern
%type <Parsetree.pattern> parse_pattern
+%start parse_constr_longident
+%type <Longident.t> parse_constr_longident
+%start parse_val_longident
+%type <Longident.t> parse_val_longident
+%start parse_mty_longident
+%type <Longident.t> parse_mty_longident
+%start parse_mod_ext_longident
+%type <Longident.t> parse_mod_ext_longident
+%start parse_mod_longident
+%type <Longident.t> parse_mod_longident
+%start parse_any_longident
+%type <Longident.t> parse_any_longident
%%
/* macros */
{ $1 }
;
+parse_mty_longident:
+ mty_longident EOF
+ { $1 }
+;
+
+parse_val_longident:
+ val_longident EOF
+ { $1 }
+;
+
+parse_constr_longident:
+ constr_longident EOF
+ { $1 }
+;
+
+parse_mod_ext_longident:
+ mod_ext_longident EOF
+ { $1 }
+;
+
+parse_mod_longident:
+ mod_longident EOF
+ { $1 }
+;
+
+parse_any_longident:
+ any_longident EOF
+ { $1 }
+;
(* -------------------------------------------------------------------------- *)
(* Functor arguments appear in module expressions and module types. *)
{ Ptyp_object ([], Closed) }
| tys = actual_type_parameters
HASH
- cid = mkrhs(class_longident)
+ cid = mkrhs(clty_longident)
{ Ptyp_class(cid, tys) }
| LBRACKET tag_field RBRACKET
(* not row_field; see CONFLICTS *)
constant:
| INT { let (n, m) = $1 in Pconst_integer (n, m) }
| CHAR { Pconst_char $1 }
- | STRING { let (s, d) = $1 in Pconst_string (s, d) }
+ | STRING { let (s, strloc, d) = $1 in Pconst_string (s, strloc, d) }
| FLOAT { let (f, m) = $1 in Pconst_float (f, m) }
;
signed_constant:
UIDENT { $1 }
| LIDENT { $1 }
;
-val_ident:
- LIDENT { $1 }
+val_extra_ident:
| LPAREN operator RPAREN { $2 }
| LPAREN operator error { unclosed "(" $loc($1) ")" $loc($3) }
| LPAREN error { expecting $loc($2) "operator" }
| LPAREN MODULE error { expecting $loc($3) "module-expr" }
;
+val_ident:
+ LIDENT { $1 }
+ | val_extra_ident { $1 }
+;
operator:
PREFIXOP { $1 }
| LETOP { $1 }
| { "" }
| SEMI DOTDOT { ";.." }
;
-constr_ident:
- UIDENT { $1 }
+
+%inline constr_extra_ident:
+ | LPAREN COLONCOLON RPAREN { "::" }
+;
+constr_extra_nonprefix_ident:
| LBRACKET RBRACKET { "[]" }
| LPAREN RPAREN { "()" }
- | LPAREN COLONCOLON RPAREN { "::" }
| FALSE { "false" }
| TRUE { "true" }
;
-
-val_longident:
- val_ident { Lident $1 }
- | mod_longident DOT val_ident { Ldot($1, $3) }
+constr_ident:
+ UIDENT { $1 }
+ | constr_extra_ident { $1 }
+ | constr_extra_nonprefix_ident { $1 }
;
constr_longident:
- mod_longident %prec below_DOT { $1 }
- | mod_longident DOT LPAREN COLONCOLON RPAREN { Ldot($1,"::") }
- | LBRACKET RBRACKET { Lident "[]" }
- | LPAREN RPAREN { Lident "()" }
- | LPAREN COLONCOLON RPAREN { Lident "::" }
- | FALSE { Lident "false" }
- | TRUE { Lident "true" }
+ mod_longident %prec below_DOT { $1 } /* A.B.x vs (A).B.x */
+ | mod_longident DOT constr_extra_ident { Ldot($1,$3) }
+ | constr_extra_ident { Lident $1 }
+ | constr_extra_nonprefix_ident { Lident $1 }
+;
+mk_longident(prefix,final):
+ | final { Lident $1 }
+ | prefix DOT final { Ldot($1,$3) }
+;
+val_longident:
+ mk_longident(mod_longident, val_ident) { $1 }
;
label_longident:
- LIDENT { Lident $1 }
- | mod_longident DOT LIDENT { Ldot($1, $3) }
+ mk_longident(mod_longident, LIDENT) { $1 }
;
type_longident:
- LIDENT { Lident $1 }
- | mod_ext_longident DOT LIDENT { Ldot($1, $3) }
+ mk_longident(mod_ext_longident, LIDENT) { $1 }
;
mod_longident:
- UIDENT { Lident $1 }
- | mod_longident DOT UIDENT { Ldot($1, $3) }
+ mk_longident(mod_longident, UIDENT) { $1 }
;
mod_ext_longident:
- UIDENT { Lident $1 }
- | mod_ext_longident DOT UIDENT { Ldot($1, $3) }
+ mk_longident(mod_ext_longident, UIDENT) { $1 }
| mod_ext_longident LPAREN mod_ext_longident RPAREN
{ lapply ~loc:$sloc $1 $3 }
| mod_ext_longident LPAREN error
{ expecting $loc($3) "module path" }
;
mty_longident:
- ident { Lident $1 }
- | mod_ext_longident DOT ident { Ldot($1, $3) }
+ mk_longident(mod_ext_longident,ident) { $1 }
;
clty_longident:
- LIDENT { Lident $1 }
- | mod_ext_longident DOT LIDENT { Ldot($1, $3) }
+ mk_longident(mod_ext_longident,LIDENT) { $1 }
;
class_longident:
- LIDENT { Lident $1 }
- | mod_longident DOT LIDENT { Ldot($1, $3) }
+ mk_longident(mod_longident,LIDENT) { $1 }
+;
+
+/* For compiler-libs: parse all valid longidents and a little more:
+ final identifiers which are value specific are accepted even when
+ the path prefix is only valid for types: (e.g. F(X).(::)) */
+any_longident:
+ | mk_longident (mod_ext_longident,
+ ident | constr_extra_ident | val_extra_ident { $1 }
+ ) { $1 }
+ | constr_extra_nonprefix_ident { Lident $1 }
;
/* Toplevel directives */
;
%inline toplevel_directive_argument:
- | STRING { let (s, _) = $1 in Pdir_string s }
+ | STRING { let (s, _, _) = $1 in Pdir_string s }
| INT { let (n, m) = $1 in Pdir_int (n ,m) }
| val_longident { Pdir_ident $1 }
| mod_longident { Pdir_ident $1 }
%inline raw_string:
s = STRING
- { fst s }
+ { let body, _, _ = s in body }
;
name_tag:
ext attributes { $1, $2 }
;
extension:
- LBRACKETPERCENT attr_id payload RBRACKET { ($2, $3) }
+ | LBRACKETPERCENT attr_id payload RBRACKET { ($2, $3) }
+ | QUOTED_STRING_EXPR
+ { mk_quotedext ~loc:$sloc $1 }
;
item_extension:
- LBRACKETPERCENTPERCENT attr_id payload RBRACKET { ($2, $3) }
+ | LBRACKETPERCENTPERCENT attr_id payload RBRACKET { ($2, $3) }
+ | QUOTED_STRING_ITEM
+ { mk_quotedext ~loc:$sloc $1 }
;
payload:
structure { PStr $1 }
*)
| Pconst_char of char
(* 'c' *)
- | Pconst_string of string * string option
+ | Pconst_string of string * Location.t * string option
(* "constant"
{delim|other constant|delim}
+
+ The location span the content of the string, without the delimiters.
*)
| Pconst_float of string * char option
(* 3.4 2e5 1.4e-4
let constant f = function
| Pconst_char i ->
pp f "%C" i
- | Pconst_string (i, None) ->
+ | Pconst_string (i, _, None) ->
pp f "%S" i
- | Pconst_string (i, Some delim) ->
+ | Pconst_string (i, _, Some delim) ->
pp f "{%s|%s|%s}" delim i delim
| Pconst_integer (i, None) ->
paren (first_is '-' i) (fun f -> pp f "%s") f i
;;
let fmt_location f loc =
- let p_2nd_name = loc.loc_start.pos_fname <> loc.loc_end.pos_fname in
- fprintf f "(%a..%a)" (fmt_position true) loc.loc_start
- (fmt_position p_2nd_name) loc.loc_end;
- if loc.loc_ghost then fprintf f " ghost";
+ if not !Clflags.locations then ()
+ else begin
+ let p_2nd_name = loc.loc_start.pos_fname <> loc.loc_end.pos_fname in
+ fprintf f "(%a..%a)" (fmt_position true) loc.loc_start
+ (fmt_position p_2nd_name) loc.loc_end;
+ if loc.loc_ghost then fprintf f " ghost";
+ end
;;
let rec fmt_longident_aux f x =
match x with
| Pconst_integer (i,m) -> fprintf f "PConst_int (%s,%a)" i fmt_char_option m;
| Pconst_char (c) -> fprintf f "PConst_char %02x" (Char.code c);
- | Pconst_string (s, None) -> fprintf f "PConst_string(%S,None)" s;
- | Pconst_string (s, Some delim) ->
- fprintf f "PConst_string (%S,Some %S)" s delim;
+ | Pconst_string (s, strloc, None) ->
+ fprintf f "PConst_string(%S,%a,None)" s fmt_location strloc ;
+ | Pconst_string (s, strloc, Some delim) ->
+ fprintf f "PConst_string (%S,%a,Some %S)" s fmt_location strloc delim;
| Pconst_float (s,m) -> fprintf f "PConst_float (%s,%a)" s fmt_char_option m;
;;
-afl_b.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \
+interp_b.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \
+ caml/fix_code.h caml/instrtrace.h caml/instruct.h caml/interp.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
+ caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \
+ caml/startup_aux.h caml/jumptbl.h
+misc_b.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
+ caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \
+ caml/version.h
+stacks_b.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \
+ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h
+fix_code_b.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \
+ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \
+ caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/misc.h caml/mlvalues.h caml/reverse.h
+startup_aux_b.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \
+ caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h
+ caml/domain.h caml/callback.h caml/major_gc.h caml/dynlink.h \
+ caml/osdeps.h caml/memory.h caml/startup_aux.h caml/memprof.h \
+ caml/roots.h
+startup_byt_b.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
+ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \
+ caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h \
+ caml/eventlog.h caml/exec.h caml/fail.h caml/fix_code.h caml/freelist.h \
+ caml/gc_ctrl.h caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h \
+ caml/io.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h \
+ caml/printexc.h caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h \
+ caml/startup.h caml/startup_aux.h caml/version.h
+freelist_b.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \
+ caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \
+ caml/mlvalues.h caml/eventlog.h
+major_gc_b.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \
+ caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
+ caml/signals.h caml/weak.h caml/memprof.h caml/eventlog.h
+minor_gc_b.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \
+ caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \
+ caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h \
+ caml/eventlog.h
+memory_b.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \
+ caml/memory.h caml/eventlog.h
alloc_b.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
caml/stacks.h caml/memory.h caml/signals.h
-array_b.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+roots_byt_b.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \
+ caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
+ caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h \
+ caml/eventlog.h
+globroots_b.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \
+ caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
- caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
-backtrace_b.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/roots.h caml/memory.h caml/globroots.h caml/roots.h
+fail_byt_b.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \
- caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h
+ caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \
+ caml/stacks.h caml/memory.h
+signals_b.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \
+ caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \
+ caml/roots.h caml/finalise.h
+signals_byt_b.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \
+ caml/memory.h caml/config.h caml/gc.h caml/mlvalues.h caml/misc.h \
+ caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \
+ caml/signals.h caml/signals_machdep.h
+printexc_b.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \
+ caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/memprof.h caml/roots.h caml/memory.h
backtrace_byt_b.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \
caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \
caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \
caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h
-backtrace_nat_b.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \
- caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h caml/stack.h
-bigarray_b.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+backtrace_b.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \
- caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/signals.h
-callback_b.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/mlvalues.h caml/interp.h caml/instruct.h caml/fix_code.h \
- caml/stacks.h caml/memory.h
-clambda_checks_b.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \
- caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl
-compact_b.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \
- caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \
+ caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h
compare_b.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \
caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
caml/mlvalues.h
-custom_b.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \
+ints_b.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
+ caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/mlvalues.h caml/signals.h
-debugger_b.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h
+eventlog_b.$(O): eventlog.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/fail.h caml/fix_code.h \
- caml/instruct.h caml/intext.h caml/io.h caml/io.h caml/mlvalues.h \
- caml/stacks.h caml/sys.h
-domain_b.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \
+ caml/eventlog.h caml/misc.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/osdeps.h caml/memory.h
+floats_b.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h
+str_b.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h
-dynlink_b.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \
+ caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h
+array_b.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
- caml/memory.h caml/prims.h caml/signals.h
-dynlink_nat_b.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \
- caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/signals.h caml/eventlog.h caml/spacetime.h caml/io.h caml/stack.h
+io_b.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
+ caml/signals.h caml/sys.h
extern_b.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \
caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/misc.h caml/mlvalues.h caml/reverse.h
-fail_byt_b.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+intern_b.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \
+ caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \
+ caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \
+ caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \
+ caml/misc.h caml/reverse.h caml/signals.h
+hash_b.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
+ caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h
+sys_b.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \
+ caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \
+ caml/startup_aux.h
+meta_b.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \
+ caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \
+ caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \
caml/stacks.h caml/memory.h
-fail_nat_b.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+parsing_b.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \
+ caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/alloc.h
+gc_ctrl_b.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \
+ caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \
+ caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \
+ caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h \
+ caml/eventlog.h caml/stacks.h caml/startup_aux.h
+md5_b.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/mlvalues.h caml/io.h caml/reverse.h
+obj_b.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \
+ caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
+lexing_b.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h
+callback_b.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/mlvalues.h caml/interp.h caml/instruct.h caml/fix_code.h \
+ caml/stacks.h caml/memory.h
+debugger_b.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/fail.h caml/fix_code.h \
+ caml/instruct.h caml/intext.h caml/io.h caml/io.h caml/mlvalues.h \
+ caml/stacks.h caml/sys.h
+weak_b.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h caml/eventlog.h
+compact_b.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \
- caml/stack.h caml/roots.h caml/memory.h caml/callback.h
+ caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \
+ caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h \
+ caml/memprof.h caml/eventlog.h
finalise_b.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \
caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \
caml/roots.h caml/signals.h
-fix_code_b.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \
- caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/misc.h caml/mlvalues.h caml/reverse.h
-floats_b.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h
-freelist_b.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \
- caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \
- caml/mlvalues.h
-gc_ctrl_b.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \
- caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h caml/stacks.h \
- caml/startup_aux.h
-globroots_b.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \
- caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
- caml/roots.h caml/memory.h caml/globroots.h caml/roots.h
-hash_b.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
- caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h
-instrtrace_b.$(O): instrtrace.c
-intern_b.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \
- caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \
- caml/misc.h caml/reverse.h caml/signals.h
-interp_b.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \
- caml/fix_code.h caml/instrtrace.h caml/instruct.h caml/interp.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \
- caml/startup_aux.h caml/jumptbl.h
-ints_b.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
- caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h
-io_b.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/signals.h caml/sys.h
-lexing_b.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h
-main_b.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h
-major_gc_b.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \
- caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
- caml/signals.h caml/weak.h
-md5_b.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/mlvalues.h caml/io.h caml/reverse.h
-memory_b.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \
- caml/memory.h
-memprof_b.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \
- caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \
- caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
- caml/weak.h caml/stack.h caml/misc.h
-meta_b.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \
- caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \
- caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \
- caml/stacks.h caml/memory.h
-minor_gc_b.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \
- caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \
- caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h
-misc_b.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
- caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \
- caml/version.h
-obj_b.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \
- caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
-parsing_b.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \
- caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/alloc.h
-prims_b.$(O): prims.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
- caml/prims.h
-printexc_b.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \
- caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/memprof.h caml/roots.h caml/memory.h
-roots_byt_b.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h
-roots_nat_b.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h
-signals_b.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \
- caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \
- caml/roots.h caml/finalise.h
-signals_byt_b.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \
- caml/memory.h caml/config.h caml/gc.h caml/mlvalues.h caml/misc.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \
- caml/signals.h caml/signals_machdep.h
-signals_nat_b.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \
- signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \
- caml/memprof.h caml/roots.h caml/finalise.h
-spacetime_byt_b.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/mlvalues.h
-spacetime_nat_b.$(O): spacetime_nat.c caml/config.h caml/m.h caml/s.h \
- caml/alloc.h caml/misc.h caml/config.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/backtrace_prim.h \
- caml/backtrace.h caml/exec.h caml/fail.h caml/gc.h caml/intext.h \
- caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/roots.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \
- caml/stack.h
-spacetime_snapshot_b.$(O): spacetime_snapshot.c caml/alloc.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
- caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/gc_ctrl.h \
- caml/intext.h caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
- caml/memory.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \
- caml/stack.h
-stacks_b.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h
-startup_aux_b.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \
- caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/callback.h caml/major_gc.h caml/dynlink.h \
- caml/osdeps.h caml/memory.h caml/startup_aux.h
-startup_byt_b.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \
- caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h caml/exec.h \
- caml/fail.h caml/fix_code.h caml/freelist.h caml/gc_ctrl.h \
- caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h caml/io.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/minor_gc.h caml/misc.h \
- caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h caml/printexc.h \
- caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h caml/startup.h \
- caml/startup_aux.h caml/version.h
-startup_nat_b.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \
- caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \
- caml/debugger.h caml/domain.h caml/fail.h caml/freelist.h caml/gc.h \
- caml/gc_ctrl.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/printexc.h caml/stack.h caml/startup_aux.h caml/sys.h
-str_b.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h
-sys_b.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \
- caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \
- caml/startup_aux.h
-unix_b.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
- caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h
-weak_b.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h
-win32_b.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \
- caml/sys.h caml/config.h
-afl_bd.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h
-alloc_bd.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/stacks.h caml/memory.h caml/signals.h
-array_bd.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
- caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
-backtrace_bd.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \
- caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h
-backtrace_byt_bd.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
- caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \
- caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \
- caml/fix_code.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \
- caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \
- caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h
-backtrace_nat_bd.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \
- caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h caml/stack.h
-bigarray_bd.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \
- caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/signals.h
-callback_bd.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/mlvalues.h caml/interp.h caml/instruct.h caml/fix_code.h \
- caml/stacks.h caml/memory.h
-clambda_checks_bd.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \
- caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl
-compact_bd.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \
- caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h
-compare_bd.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \
- caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h
-custom_bd.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+custom_b.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/mlvalues.h caml/signals.h
-debugger_bd.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/fail.h caml/fix_code.h \
- caml/instruct.h caml/intext.h caml/io.h caml/io.h caml/mlvalues.h \
- caml/stacks.h caml/sys.h
-domain_bd.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h
-dynlink_bd.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
- caml/memory.h caml/prims.h caml/signals.h
-dynlink_nat_bd.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \
- caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h
-extern_bd.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \
- caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/misc.h caml/mlvalues.h caml/reverse.h
-fail_byt_bd.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \
- caml/stacks.h caml/memory.h
-fail_nat_bd.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \
- caml/stack.h caml/roots.h caml/memory.h caml/callback.h
-finalise_bd.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \
- caml/roots.h caml/signals.h
-fix_code_bd.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/mlvalues.h caml/signals.h
+dynlink_b.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \
- caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/misc.h caml/mlvalues.h caml/reverse.h
-floats_bd.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h
-freelist_bd.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \
- caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \
+ caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \
- caml/mlvalues.h
-gc_ctrl_bd.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \
- caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h caml/stacks.h \
- caml/startup_aux.h
-globroots_bd.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \
- caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
- caml/roots.h caml/memory.h caml/globroots.h caml/roots.h
-hash_bd.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
- caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h
-instrtrace_bd.$(O): instrtrace.c caml/instrtrace.h caml/mlvalues.h \
- caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/instruct.h caml/misc.h caml/mlvalues.h \
- caml/opnames.h caml/prims.h caml/stacks.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/startup_aux.h
-intern_bd.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \
- caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \
- caml/misc.h caml/reverse.h caml/signals.h
-interp_bd.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \
- caml/fix_code.h caml/instrtrace.h caml/instruct.h caml/interp.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \
- caml/startup_aux.h
-ints_bd.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
- caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
+ caml/memory.h caml/prims.h caml/signals.h
+spacetime_byt_b.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \
+ caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/mlvalues.h
+afl_b.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h
-io_bd.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
+ caml/domain.h
+unix_b.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \
caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/signals.h caml/sys.h
-lexing_bd.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
+ caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h
+bigarray_b.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h
-main_bd.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \
+ caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/signals.h
+main_b.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h
-major_gc_bd.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \
- caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
- caml/signals.h caml/weak.h
-md5_bd.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/mlvalues.h caml/io.h caml/reverse.h
-memory_bd.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \
- caml/memory.h
-memprof_bd.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \
+memprof_b.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \
caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \
caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
- caml/weak.h caml/stack.h caml/misc.h
-meta_bd.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/weak.h caml/stack.h caml/misc.h caml/compact.h caml/printexc.h \
+ caml/eventlog.h
+domain_b.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h
+win32_b.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \
- caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \
- caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \
- caml/stacks.h caml/memory.h
-minor_gc_bd.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \
- caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \
- caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h
+ caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \
+ caml/sys.h caml/config.h
+instrtrace_b.$(O): instrtrace.c
+interp_bd.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \
+ caml/fix_code.h caml/instrtrace.h caml/instruct.h caml/interp.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
+ caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \
+ caml/startup_aux.h
misc_bd.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \
caml/version.h
-obj_bd.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \
- caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
-parsing_bd.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \
- caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/alloc.h
-prims_bd.$(O): prims.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
- caml/prims.h
-printexc_bd.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \
- caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/memprof.h caml/roots.h caml/memory.h
-roots_byt_bd.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h
-roots_nat_bd.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h
-signals_bd.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \
- caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \
- caml/roots.h caml/finalise.h
-signals_byt_bd.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \
- caml/memory.h caml/config.h caml/gc.h caml/mlvalues.h caml/misc.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \
- caml/signals.h caml/signals_machdep.h
-signals_nat_bd.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \
- signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \
- caml/memprof.h caml/roots.h caml/finalise.h
-spacetime_byt_bd.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/mlvalues.h
-spacetime_nat_bd.$(O): spacetime_nat.c caml/config.h caml/m.h caml/s.h \
- caml/alloc.h caml/misc.h caml/config.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/backtrace_prim.h \
- caml/backtrace.h caml/exec.h caml/fail.h caml/gc.h caml/intext.h \
- caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/roots.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \
- caml/stack.h
-spacetime_snapshot_bd.$(O): spacetime_snapshot.c caml/alloc.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
- caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/gc_ctrl.h \
- caml/intext.h caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
- caml/memory.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \
- caml/stack.h
stacks_bd.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \
caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h
+fix_code_bd.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \
+ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \
+ caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/misc.h caml/mlvalues.h caml/reverse.h
startup_aux_bd.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \
caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/callback.h caml/major_gc.h caml/dynlink.h \
- caml/osdeps.h caml/memory.h caml/startup_aux.h
+ caml/osdeps.h caml/memory.h caml/startup_aux.h caml/memprof.h \
+ caml/roots.h
startup_byt_bd.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \
- caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h caml/exec.h \
- caml/fail.h caml/fix_code.h caml/freelist.h caml/gc_ctrl.h \
- caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h caml/io.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/minor_gc.h caml/misc.h \
- caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h caml/printexc.h \
- caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h caml/startup.h \
- caml/startup_aux.h caml/version.h
-startup_nat_bd.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \
- caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \
- caml/debugger.h caml/domain.h caml/fail.h caml/freelist.h caml/gc.h \
- caml/gc_ctrl.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/printexc.h caml/stack.h caml/startup_aux.h caml/sys.h
-str_bd.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h \
+ caml/eventlog.h caml/exec.h caml/fail.h caml/fix_code.h caml/freelist.h \
+ caml/gc_ctrl.h caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h \
+ caml/io.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h \
+ caml/printexc.h caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h \
+ caml/startup.h caml/startup_aux.h caml/version.h
+freelist_bd.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \
+ caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h
-sys_bd.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \
- caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \
- caml/startup_aux.h
-unix_bd.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \
+ caml/mlvalues.h caml/eventlog.h
+major_gc_bd.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
- caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h
-weak_bd.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h
-win32_bd.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \
- caml/sys.h caml/config.h
-afl_bi.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h
-alloc_bi.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \
+ caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
+ caml/signals.h caml/weak.h caml/memprof.h caml/eventlog.h
+minor_gc_bd.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \
+ caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \
+ caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h \
+ caml/eventlog.h
+memory_bd.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \
+ caml/memory.h caml/eventlog.h
+alloc_bd.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
caml/stacks.h caml/memory.h caml/signals.h
-array_bi.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+roots_byt_bd.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \
+ caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
+ caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h \
+ caml/eventlog.h
+globroots_bd.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \
+ caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
- caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
-backtrace_bi.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/roots.h caml/memory.h caml/globroots.h caml/roots.h
+fail_byt_bd.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \
- caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h
-backtrace_byt_bi.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \
+ caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \
+ caml/stacks.h caml/memory.h
+signals_bd.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \
+ caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \
+ caml/roots.h caml/finalise.h
+signals_byt_bd.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \
+ caml/memory.h caml/config.h caml/gc.h caml/mlvalues.h caml/misc.h \
+ caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \
+ caml/signals.h caml/signals_machdep.h
+printexc_bd.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \
+ caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/memprof.h caml/roots.h caml/memory.h
+backtrace_byt_bd.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \
caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \
caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \
caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \
caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h
-backtrace_nat_bi.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \
- caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h caml/stack.h
-bigarray_bi.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+backtrace_bd.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \
- caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/signals.h
-callback_bi.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/mlvalues.h caml/interp.h caml/instruct.h caml/fix_code.h \
- caml/stacks.h caml/memory.h
-clambda_checks_bi.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \
- caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl
-compact_bi.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \
- caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h
-compare_bi.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \
+ caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h
+compare_bd.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \
caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
caml/mlvalues.h
-custom_bi.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \
+ints_bd.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
+ caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/mlvalues.h caml/signals.h
-debugger_bi.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h
+eventlog_bd.$(O): eventlog.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/fail.h caml/fix_code.h \
- caml/instruct.h caml/intext.h caml/io.h caml/io.h caml/mlvalues.h \
- caml/stacks.h caml/sys.h
-domain_bi.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \
+ caml/eventlog.h caml/misc.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/osdeps.h caml/memory.h
+floats_bd.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h
+str_bd.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h
-dynlink_bi.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \
+ caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h
+array_bd.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
- caml/memory.h caml/prims.h caml/signals.h
-dynlink_nat_bi.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \
- caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h
-extern_bi.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/signals.h caml/eventlog.h caml/spacetime.h caml/io.h caml/stack.h
+io_bd.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
+ caml/signals.h caml/sys.h
+extern_bd.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \
caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/misc.h caml/mlvalues.h caml/reverse.h
-fail_byt_bi.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+intern_bd.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \
+ caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \
+ caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \
+ caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \
+ caml/misc.h caml/reverse.h caml/signals.h
+hash_bd.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
+ caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h
+sys_bd.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \
+ caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \
+ caml/startup_aux.h
+meta_bd.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \
+ caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \
+ caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \
caml/stacks.h caml/memory.h
-fail_nat_bi.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+parsing_bd.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \
+ caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/alloc.h
+gc_ctrl_bd.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \
+ caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \
+ caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \
+ caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h \
+ caml/eventlog.h caml/stacks.h caml/startup_aux.h
+md5_bd.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/mlvalues.h caml/io.h caml/reverse.h
+obj_bd.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \
+ caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
+lexing_bd.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h
+callback_bd.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/mlvalues.h caml/interp.h caml/instruct.h caml/fix_code.h \
+ caml/stacks.h caml/memory.h
+debugger_bd.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/fail.h caml/fix_code.h \
+ caml/instruct.h caml/intext.h caml/io.h caml/io.h caml/mlvalues.h \
+ caml/stacks.h caml/sys.h
+weak_bd.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h caml/eventlog.h
+compact_bd.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \
- caml/stack.h caml/roots.h caml/memory.h caml/callback.h
-finalise_bi.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \
+ caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \
+ caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h \
+ caml/memprof.h caml/eventlog.h
+finalise_bd.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \
caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \
caml/roots.h caml/signals.h
-fix_code_bi.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \
- caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/misc.h caml/mlvalues.h caml/reverse.h
-floats_bi.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+custom_bd.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h
-freelist_bi.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \
- caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \
+ caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/mlvalues.h caml/signals.h
+dynlink_bd.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
+ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \
- caml/mlvalues.h
-gc_ctrl_bi.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \
- caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h caml/stacks.h \
- caml/startup_aux.h
-globroots_bi.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \
- caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
- caml/roots.h caml/memory.h caml/globroots.h caml/roots.h
-hash_bi.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
- caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h
-instrtrace_bi.$(O): instrtrace.c
-intern_bi.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
+ caml/memory.h caml/prims.h caml/signals.h
+spacetime_byt_bd.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \
+ caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/mlvalues.h
+afl_bd.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h
+unix_bd.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
+ caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h
+bigarray_bd.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \
- caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \
+ caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \
+ caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/signals.h
+main_bd.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \
- caml/misc.h caml/reverse.h caml/signals.h
+ caml/domain.h
+memprof_bd.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \
+ caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \
+ caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
+ caml/weak.h caml/stack.h caml/misc.h caml/compact.h caml/printexc.h \
+ caml/eventlog.h
+domain_bd.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h
+win32_bd.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \
+ caml/sys.h caml/config.h
+instrtrace_bd.$(O): instrtrace.c caml/instrtrace.h caml/mlvalues.h \
+ caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/instruct.h caml/misc.h caml/mlvalues.h \
+ caml/opnames.h caml/prims.h caml/stacks.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/startup_aux.h
interp_bi.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \
caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \
caml/startup_aux.h caml/jumptbl.h
-ints_bi.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
- caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h
-io_bi.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/signals.h caml/sys.h
-lexing_bi.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h
-main_bi.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \
+misc_bi.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
+ caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \
+ caml/version.h
+stacks_bi.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \
+ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h
+fix_code_bi.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \
+ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \
+ caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/misc.h caml/mlvalues.h caml/reverse.h
+startup_aux_bi.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \
+ caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h
+ caml/domain.h caml/callback.h caml/major_gc.h caml/dynlink.h \
+ caml/osdeps.h caml/memory.h caml/startup_aux.h caml/memprof.h \
+ caml/roots.h
+startup_byt_bi.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
+ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \
+ caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h \
+ caml/eventlog.h caml/exec.h caml/fail.h caml/fix_code.h caml/freelist.h \
+ caml/gc_ctrl.h caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h \
+ caml/io.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h \
+ caml/printexc.h caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h \
+ caml/startup.h caml/startup_aux.h caml/version.h
+freelist_bi.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \
+ caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \
+ caml/mlvalues.h caml/eventlog.h
major_gc_bi.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \
caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \
caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
- caml/signals.h caml/weak.h
-md5_bi.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/mlvalues.h caml/io.h caml/reverse.h
-memory_bi.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \
- caml/memory.h
-memprof_bi.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \
- caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \
- caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
- caml/weak.h caml/stack.h caml/misc.h
-meta_bi.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \
- caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \
- caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \
- caml/stacks.h caml/memory.h
+ caml/signals.h caml/weak.h caml/memprof.h caml/eventlog.h
minor_gc_bi.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \
caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \
caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \
- caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h
-misc_bi.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
- caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \
- caml/version.h
-obj_bi.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \
- caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
-parsing_bi.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \
- caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/alloc.h
-prims_bi.$(O): prims.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
- caml/prims.h
-printexc_bi.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \
- caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/memprof.h caml/roots.h caml/memory.h
+ caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h \
+ caml/eventlog.h
+memory_bi.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \
+ caml/memory.h caml/eventlog.h
+alloc_bi.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/stacks.h caml/memory.h caml/signals.h
roots_byt_bi.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \
caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h
-roots_nat_bi.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h
+ caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h \
+ caml/eventlog.h
+globroots_bi.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \
+ caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/roots.h caml/memory.h caml/globroots.h caml/roots.h
+fail_byt_bi.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \
+ caml/stacks.h caml/memory.h
signals_bi.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \
caml/signals.h caml/signals_machdep.h
-signals_nat_bi.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
+printexc_bi.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \
+ caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \
- signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \
- caml/memprof.h caml/roots.h caml/finalise.h
-spacetime_byt_bi.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/mlvalues.h
-spacetime_nat_bi.$(O): spacetime_nat.c caml/config.h caml/m.h caml/s.h \
- caml/alloc.h caml/misc.h caml/config.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/backtrace_prim.h \
- caml/backtrace.h caml/exec.h caml/fail.h caml/gc.h caml/intext.h \
- caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/roots.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \
- caml/stack.h
-spacetime_snapshot_bi.$(O): spacetime_snapshot.c caml/alloc.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
- caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/gc_ctrl.h \
- caml/intext.h caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
- caml/memory.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \
- caml/stack.h
-stacks_bi.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \
+ caml/memprof.h caml/roots.h caml/memory.h
+backtrace_byt_bi.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
+ caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \
+ caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \
+ caml/fix_code.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \
+ caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \
+ caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h
+backtrace_bi.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h
-startup_aux_bi.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \
- caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/callback.h caml/major_gc.h caml/dynlink.h \
- caml/osdeps.h caml/memory.h caml/startup_aux.h
-startup_byt_bi.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \
- caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h caml/exec.h \
- caml/fail.h caml/fix_code.h caml/freelist.h caml/gc_ctrl.h \
- caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h caml/io.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/minor_gc.h caml/misc.h \
- caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h caml/printexc.h \
- caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h caml/startup.h \
- caml/startup_aux.h caml/version.h
-startup_nat_bi.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \
- caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \
- caml/debugger.h caml/domain.h caml/fail.h caml/freelist.h caml/gc.h \
- caml/gc_ctrl.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
+ caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \
+ caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h
+compare_bi.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \
+ caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
+ caml/mlvalues.h
+ints_bi.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
+ caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/printexc.h caml/stack.h caml/startup_aux.h caml/sys.h
+ caml/domain.h caml/misc.h caml/mlvalues.h
+eventlog_bi.$(O): eventlog.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/eventlog.h caml/misc.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/osdeps.h caml/memory.h
+floats_bi.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h
str_bi.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h
+array_bi.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/signals.h caml/eventlog.h caml/spacetime.h caml/io.h caml/stack.h
+io_bi.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
+ caml/signals.h caml/sys.h
+extern_bi.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \
+ caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/misc.h caml/mlvalues.h caml/reverse.h
+intern_bi.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \
+ caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \
+ caml/misc.h caml/reverse.h caml/signals.h
+hash_bi.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
+ caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h
sys_bi.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \
caml/startup_aux.h
-unix_bi.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
- caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h
-weak_bi.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h
-win32_bi.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+meta_bi.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \
- caml/sys.h caml/config.h
-afl_bpic.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h
-alloc_bpic.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/stacks.h caml/memory.h caml/signals.h
-array_bpic.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \
+ caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \
+ caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \
+ caml/stacks.h caml/memory.h
+parsing_bi.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \
+ caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/alloc.h
+gc_ctrl_bi.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \
+ caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \
+ caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h \
+ caml/eventlog.h caml/stacks.h caml/startup_aux.h
+md5_bi.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/mlvalues.h caml/io.h caml/reverse.h
+obj_bi.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \
caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
-backtrace_bpic.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \
- caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h
-backtrace_byt_bpic.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
- caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \
- caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \
- caml/fix_code.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \
- caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \
- caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h
-backtrace_nat_bpic.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \
- caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h caml/stack.h
-bigarray_bpic.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+lexing_bi.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \
- caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/signals.h
-callback_bpic.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \
+ caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h
+callback_bi.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \
caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/mlvalues.h caml/interp.h caml/instruct.h caml/fix_code.h \
caml/stacks.h caml/memory.h
-clambda_checks_bpic.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \
- caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl
-compact_bpic.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+debugger_bi.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/fail.h caml/fix_code.h \
+ caml/instruct.h caml/intext.h caml/io.h caml/io.h caml/mlvalues.h \
+ caml/stacks.h caml/sys.h
+weak_bi.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h caml/eventlog.h
+compact_bi.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \
- caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h
-compare_bpic.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \
- caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h
-custom_bpic.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h \
+ caml/memprof.h caml/eventlog.h
+finalise_bi.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \
+ caml/roots.h caml/signals.h
+custom_bi.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/mlvalues.h caml/signals.h
-debugger_bpic.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/fail.h caml/fix_code.h \
- caml/instruct.h caml/intext.h caml/io.h caml/io.h caml/mlvalues.h \
- caml/stacks.h caml/sys.h
-domain_bpic.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h
-dynlink_bpic.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
+dynlink_bi.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
caml/memory.h caml/prims.h caml/signals.h
-dynlink_nat_bpic.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \
+spacetime_byt_bi.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \
+ caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/mlvalues.h
+afl_bi.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \
- caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h
-extern_bpic.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \
- caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/misc.h caml/mlvalues.h caml/reverse.h
-fail_byt_bpic.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \
+ caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \
- caml/stacks.h caml/memory.h
-fail_nat_bpic.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/domain.h
+unix_bi.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
+ caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h
+bigarray_bi.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \
+ caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \
+ caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/signals.h
+main_bi.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \
- caml/stack.h caml/roots.h caml/memory.h caml/callback.h
-finalise_bpic.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \
- caml/roots.h caml/signals.h
-fix_code_bpic.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \
- caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/misc.h caml/mlvalues.h caml/reverse.h
-floats_bpic.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/domain.h
+memprof_bi.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \
+ caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \
+ caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
+ caml/weak.h caml/stack.h caml/misc.h caml/compact.h caml/printexc.h \
+ caml/eventlog.h
+domain_bi.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h
-freelist_bpic.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \
- caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \
- caml/mlvalues.h
-gc_ctrl_bpic.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \
- caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h caml/stacks.h \
- caml/startup_aux.h
-globroots_bpic.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \
- caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
- caml/roots.h caml/memory.h caml/globroots.h caml/roots.h
-hash_bpic.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
- caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h
-instrtrace_bpic.$(O): instrtrace.c
-intern_bpic.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \
- caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \
+ caml/address_class.h caml/domain.h
+win32_bi.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \
- caml/misc.h caml/reverse.h caml/signals.h
+ caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \
+ caml/sys.h caml/config.h
+instrtrace_bi.$(O): instrtrace.c
interp_bpic.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \
caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \
caml/startup_aux.h caml/jumptbl.h
-ints_bpic.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
- caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h
-io_bpic.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/signals.h caml/sys.h
-lexing_bpic.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h
-main_bpic.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \
+misc_bpic.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
+ caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \
+ caml/version.h
+stacks_bpic.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \
+ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h
+fix_code_bpic.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \
+ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \
+ caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/misc.h caml/mlvalues.h caml/reverse.h
+startup_aux_bpic.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \
+ caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h
+ caml/domain.h caml/callback.h caml/major_gc.h caml/dynlink.h \
+ caml/osdeps.h caml/memory.h caml/startup_aux.h caml/memprof.h \
+ caml/roots.h
+startup_byt_bpic.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
+ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \
+ caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h \
+ caml/eventlog.h caml/exec.h caml/fail.h caml/fix_code.h caml/freelist.h \
+ caml/gc_ctrl.h caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h \
+ caml/io.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h \
+ caml/printexc.h caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h \
+ caml/startup.h caml/startup_aux.h caml/version.h
+freelist_bpic.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \
+ caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \
+ caml/mlvalues.h caml/eventlog.h
major_gc_bpic.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \
caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \
caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
- caml/signals.h caml/weak.h
-md5_bpic.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/mlvalues.h caml/io.h caml/reverse.h
-memory_bpic.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \
- caml/memory.h
-memprof_bpic.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \
- caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \
- caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
- caml/weak.h caml/stack.h caml/misc.h
-meta_bpic.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \
- caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \
- caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \
- caml/stacks.h caml/memory.h
+ caml/signals.h caml/weak.h caml/memprof.h caml/eventlog.h
minor_gc_bpic.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \
caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \
caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \
- caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h
-misc_bpic.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
- caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \
- caml/version.h
-obj_bpic.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \
- caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
-parsing_bpic.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \
- caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/alloc.h
-prims_bpic.$(O): prims.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
- caml/prims.h
-printexc_bpic.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \
- caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/memprof.h caml/roots.h caml/memory.h
+ caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h \
+ caml/eventlog.h
+memory_bpic.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \
+ caml/memory.h caml/eventlog.h
+alloc_bpic.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/stacks.h caml/memory.h caml/signals.h
roots_byt_bpic.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \
caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h
-roots_nat_bpic.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h
+ caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h \
+ caml/eventlog.h
+globroots_bpic.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \
+ caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/roots.h caml/memory.h caml/globroots.h caml/roots.h
+fail_byt_bpic.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \
+ caml/stacks.h caml/memory.h
signals_bpic.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \
caml/signals.h caml/signals_machdep.h
-signals_nat_bpic.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
+printexc_bpic.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \
+ caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \
- signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \
- caml/memprof.h caml/roots.h caml/finalise.h
-spacetime_byt_bpic.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/mlvalues.h
-spacetime_nat_bpic.$(O): spacetime_nat.c caml/config.h caml/m.h caml/s.h \
- caml/alloc.h caml/misc.h caml/config.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/backtrace_prim.h \
- caml/backtrace.h caml/exec.h caml/fail.h caml/gc.h caml/intext.h \
- caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/roots.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \
- caml/stack.h
-spacetime_snapshot_bpic.$(O): spacetime_snapshot.c caml/alloc.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
- caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/gc_ctrl.h \
- caml/intext.h caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
- caml/memory.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \
- caml/stack.h
-stacks_bpic.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \
+ caml/memprof.h caml/roots.h caml/memory.h
+backtrace_byt_bpic.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
+ caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \
+ caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \
+ caml/fix_code.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \
+ caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \
+ caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h
+backtrace_bpic.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h
-startup_aux_bpic.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \
- caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/callback.h caml/major_gc.h caml/dynlink.h \
- caml/osdeps.h caml/memory.h caml/startup_aux.h
-startup_byt_bpic.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \
- caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h caml/exec.h \
- caml/fail.h caml/fix_code.h caml/freelist.h caml/gc_ctrl.h \
- caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h caml/io.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/minor_gc.h caml/misc.h \
- caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h caml/printexc.h \
- caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h caml/startup.h \
- caml/startup_aux.h caml/version.h
-startup_nat_bpic.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \
- caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \
- caml/debugger.h caml/domain.h caml/fail.h caml/freelist.h caml/gc.h \
- caml/gc_ctrl.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
+ caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \
+ caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h
+compare_bpic.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \
+ caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
+ caml/mlvalues.h
+ints_bpic.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
+ caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/printexc.h caml/stack.h caml/startup_aux.h caml/sys.h
+ caml/domain.h caml/misc.h caml/mlvalues.h
+eventlog_bpic.$(O): eventlog.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/eventlog.h caml/misc.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/osdeps.h caml/memory.h
+floats_bpic.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h
str_bpic.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h
+array_bpic.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/signals.h caml/eventlog.h caml/spacetime.h caml/io.h caml/stack.h
+io_bpic.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
+ caml/signals.h caml/sys.h
+extern_bpic.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \
+ caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/misc.h caml/mlvalues.h caml/reverse.h
+intern_bpic.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \
+ caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \
+ caml/misc.h caml/reverse.h caml/signals.h
+hash_bpic.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
+ caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h
sys_bpic.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \
caml/startup_aux.h
-unix_bpic.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
- caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h
-weak_bpic.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h
-win32_bpic.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+meta_bpic.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \
- caml/sys.h caml/config.h
-afl_n.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h
-alloc_n.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/stacks.h caml/memory.h caml/signals.h
-array_n.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
- caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
-backtrace_n.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \
+ caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \
+ caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \
+ caml/stacks.h caml/memory.h
+parsing_bpic.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \
+ caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/alloc.h
+gc_ctrl_bpic.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \
- caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h
-backtrace_byt_n.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
- caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \
- caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \
- caml/fix_code.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \
- caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \
- caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h
-backtrace_nat_n.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \
- caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h caml/stack.h
-bigarray_n.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \
+ caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \
+ caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h \
+ caml/eventlog.h caml/stacks.h caml/startup_aux.h
+md5_bpic.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/mlvalues.h caml/io.h caml/reverse.h
+obj_bpic.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \
+ caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
+lexing_bpic.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \
- caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/signals.h
-callback_n.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \
+ caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h
+callback_bpic.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \
caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/mlvalues.h
-clambda_checks_n.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \
- caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl
-compact_n.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/interp.h caml/instruct.h caml/fix_code.h \
+ caml/stacks.h caml/memory.h
+debugger_bpic.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/fail.h caml/fix_code.h \
+ caml/instruct.h caml/intext.h caml/io.h caml/io.h caml/mlvalues.h \
+ caml/stacks.h caml/sys.h
+weak_bpic.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h caml/eventlog.h
+compact_bpic.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \
- caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h
-compare_n.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \
- caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h
-custom_n.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h \
+ caml/memprof.h caml/eventlog.h
+finalise_bpic.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \
+ caml/roots.h caml/signals.h
+custom_bpic.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/mlvalues.h caml/signals.h
-debugger_n.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h
-domain_n.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h
-dynlink_n.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
+dynlink_bpic.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
caml/memory.h caml/prims.h caml/signals.h
-dynlink_nat_n.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \
+spacetime_byt_bpic.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \
+ caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/mlvalues.h
+afl_bpic.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \
- caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h
-extern_n.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h
+unix_bpic.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
+ caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h
+bigarray_bpic.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \
- caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/misc.h caml/mlvalues.h caml/reverse.h
-fail_byt_n.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \
+ caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/signals.h
+main_bpic.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h
+memprof_bpic.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \
+ caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \
+ caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
+ caml/weak.h caml/stack.h caml/misc.h caml/compact.h caml/printexc.h \
+ caml/eventlog.h
+domain_bpic.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h
+win32_bpic.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \
- caml/stacks.h caml/memory.h
+ caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \
+ caml/sys.h caml/config.h
+instrtrace_bpic.$(O): instrtrace.c
+startup_aux_n.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \
+ caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/callback.h caml/major_gc.h caml/osdeps.h \
+ caml/memory.h caml/startup_aux.h caml/memprof.h caml/roots.h
+startup_nat_n.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \
+ caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \
+ caml/debugger.h caml/domain.h caml/eventlog.h caml/fail.h \
+ caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/intext.h caml/io.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/osdeps.h caml/memory.h caml/printexc.h caml/stack.h \
+ caml/startup_aux.h caml/sys.h
+main_n.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h
fail_nat_n.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \
caml/stack.h caml/roots.h caml/memory.h caml/callback.h
-finalise_n.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \
- caml/roots.h caml/signals.h
-fix_code_n.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \
- caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
+roots_nat_n.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \
+ caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
+ caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/misc.h caml/mlvalues.h caml/reverse.h
-floats_n.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h \
+ caml/eventlog.h
+signals_n.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h
+ caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \
+ caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \
+ caml/roots.h caml/finalise.h
+signals_nat_n.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \
+ caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \
+ signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \
+ caml/memprof.h caml/roots.h caml/finalise.h
+misc_n.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
+ caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \
+ caml/version.h
freelist_n.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \
caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \
- caml/mlvalues.h
-gc_ctrl_n.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \
- caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h caml/stack.h \
- caml/startup_aux.h
-globroots_n.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \
- caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
- caml/roots.h caml/memory.h caml/globroots.h caml/roots.h
-hash_n.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
- caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h
-instrtrace_n.$(O): instrtrace.c
-intern_n.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \
- caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \
- caml/misc.h caml/reverse.h caml/signals.h
-interp_n.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \
- caml/fix_code.h caml/instrtrace.h caml/instruct.h caml/interp.h \
+ caml/mlvalues.h caml/eventlog.h
+major_gc_n.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \
+ caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
+ caml/signals.h caml/weak.h caml/memprof.h caml/eventlog.h
+minor_gc_n.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \
+ caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \
+ caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h \
+ caml/eventlog.h
+memory_n.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \
caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \
+ caml/memory.h caml/eventlog.h
+alloc_n.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/stacks.h caml/memory.h caml/signals.h
+compare_n.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \
+ caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \
- caml/startup_aux.h caml/jumptbl.h
+ caml/mlvalues.h
ints_n.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/misc.h caml/mlvalues.h
+floats_n.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h
+str_n.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h
+array_n.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/signals.h caml/eventlog.h caml/spacetime.h caml/io.h caml/stack.h
io_n.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
caml/signals.h caml/sys.h
-lexing_n.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \
+extern_n.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \
+ caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/misc.h caml/mlvalues.h caml/reverse.h
+intern_n.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \
+ caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \
+ caml/misc.h caml/reverse.h caml/signals.h
+hash_n.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
+ caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h
+sys_n.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \
+ caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \
+ caml/startup_aux.h
+parsing_n.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \
+ caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/alloc.h
+gc_ctrl_n.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h
-main_n.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h
-major_gc_n.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \
- caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
- caml/signals.h caml/weak.h
+ caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \
+ caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \
+ caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h \
+ caml/eventlog.h caml/stack.h caml/startup_aux.h
+eventlog_n.$(O): eventlog.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/eventlog.h caml/misc.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/osdeps.h caml/memory.h
md5_n.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/mlvalues.h caml/io.h caml/reverse.h
-memory_n.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \
- caml/memory.h
-memprof_n.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \
- caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \
- caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
- caml/weak.h caml/stack.h caml/misc.h
-meta_n.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \
- caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \
- caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \
- caml/stacks.h caml/memory.h
-minor_gc_n.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \
- caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \
- caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h
-misc_n.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
- caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \
- caml/version.h
obj_n.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \
caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \
caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
-parsing_n.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \
- caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/alloc.h
-prims_n.$(O): prims.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
- caml/prims.h
+lexing_n.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h
+unix_n.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
+ caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h
printexc_n.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \
caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \
caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/memprof.h caml/roots.h caml/memory.h
-roots_byt_n.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h
-roots_nat_n.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
+callback_n.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h
-signals_n.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/mlvalues.h
+weak_n.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h caml/eventlog.h
+compact_n.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \
+ caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h \
+ caml/memprof.h caml/eventlog.h
+finalise_n.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \
+ caml/roots.h caml/signals.h
+custom_n.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \
+ caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \
- caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \
- caml/roots.h caml/finalise.h
-signals_byt_n.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \
- caml/memory.h caml/config.h caml/gc.h caml/mlvalues.h caml/misc.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \
- caml/signals.h caml/signals_machdep.h
-signals_nat_n.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \
+ caml/domain.h caml/mlvalues.h caml/signals.h
+globroots_n.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \
+ caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/roots.h caml/memory.h caml/globroots.h caml/roots.h
+backtrace_nat_n.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \
caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \
+ caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
+ caml/mlvalues.h caml/stack.h
+backtrace_n.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \
+ caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h
+dynlink_nat_n.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \
- signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \
- caml/memprof.h caml/roots.h caml/finalise.h
-spacetime_byt_n.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/mlvalues.h
+ caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \
+ caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h
+debugger_n.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h
+meta_n.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \
+ caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \
+ caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \
+ caml/stacks.h caml/memory.h
+dynlink_n.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
+ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
+ caml/memory.h caml/prims.h caml/signals.h
+clambda_checks_n.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \
+ caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl
spacetime_nat_n.$(O): spacetime_nat.c caml/config.h caml/m.h caml/s.h \
caml/alloc.h caml/misc.h caml/config.h caml/mlvalues.h \
caml/domain_state.h caml/domain_state.tbl caml/backtrace_prim.h \
caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
caml/memory.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \
- caml/stack.h
-stacks_n.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h
-startup_aux_n.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \
- caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/callback.h caml/major_gc.h caml/osdeps.h \
- caml/memory.h caml/startup_aux.h
-startup_byt_n.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \
- caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h caml/exec.h \
- caml/fail.h caml/fix_code.h caml/freelist.h caml/gc_ctrl.h \
- caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h caml/io.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/minor_gc.h caml/misc.h \
- caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h caml/printexc.h \
- caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h caml/startup.h \
- caml/startup_aux.h caml/version.h
-startup_nat_n.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \
- caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \
- caml/debugger.h caml/domain.h caml/fail.h caml/freelist.h caml/gc.h \
- caml/gc_ctrl.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/printexc.h caml/stack.h caml/startup_aux.h caml/sys.h
-str_n.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h
-sys_n.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \
- caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \
- caml/startup_aux.h
-unix_n.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
- caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h
-weak_n.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h
-win32_n.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \
- caml/sys.h caml/config.h
-afl_nd.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h
-alloc_nd.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/stacks.h caml/memory.h caml/signals.h
-array_nd.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
- caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
-backtrace_nd.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \
- caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h
-backtrace_byt_nd.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
- caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \
- caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \
- caml/fix_code.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \
- caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \
- caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h
-backtrace_nat_nd.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \
- caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h caml/stack.h
-bigarray_nd.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \
- caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/signals.h
-callback_nd.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/mlvalues.h
-clambda_checks_nd.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \
- caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl
-compact_nd.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \
- caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h
-compare_nd.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \
- caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h
-custom_nd.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \
+ caml/stack.h
+afl_n.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/mlvalues.h caml/signals.h
-debugger_nd.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/domain.h
+bigarray_n.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h
-domain_nd.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \
+ caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \
+ caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/signals.h
+memprof_n.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \
+ caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \
+ caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
+ caml/weak.h caml/stack.h caml/misc.h caml/compact.h caml/printexc.h \
+ caml/eventlog.h
+domain_n.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h
-dynlink_nd.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \
+win32_n.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \
+ caml/sys.h caml/config.h
+startup_aux_nd.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \
+ caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/callback.h caml/major_gc.h caml/osdeps.h \
+ caml/memory.h caml/startup_aux.h caml/memprof.h caml/roots.h
+startup_nat_nd.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \
+ caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \
+ caml/debugger.h caml/domain.h caml/eventlog.h caml/fail.h \
+ caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/intext.h caml/io.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
- caml/memory.h caml/prims.h caml/signals.h
-dynlink_nat_nd.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/osdeps.h caml/memory.h caml/printexc.h caml/stack.h \
+ caml/startup_aux.h caml/sys.h
+main_nd.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \
- caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h
-extern_nd.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \
- caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/misc.h caml/mlvalues.h caml/reverse.h
-fail_byt_nd.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \
+ caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \
- caml/stacks.h caml/memory.h
+ caml/domain.h
fail_nat_nd.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \
caml/stack.h caml/roots.h caml/memory.h caml/callback.h
-finalise_nd.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \
- caml/roots.h caml/signals.h
-fix_code_nd.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \
- caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
+roots_nat_nd.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \
+ caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
+ caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/misc.h caml/mlvalues.h caml/reverse.h
-floats_nd.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h \
+ caml/eventlog.h
+signals_nd.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h
+ caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \
+ caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \
+ caml/roots.h caml/finalise.h
+signals_nat_nd.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \
+ caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \
+ signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \
+ caml/memprof.h caml/roots.h caml/finalise.h
+misc_nd.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
+ caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \
+ caml/version.h
freelist_nd.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \
caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \
- caml/mlvalues.h
-gc_ctrl_nd.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \
- caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h caml/stack.h \
- caml/startup_aux.h
-globroots_nd.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \
- caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
- caml/roots.h caml/memory.h caml/globroots.h caml/roots.h
-hash_nd.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
- caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h
-instrtrace_nd.$(O): instrtrace.c caml/instrtrace.h caml/mlvalues.h \
- caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/instruct.h caml/misc.h caml/mlvalues.h \
- caml/opnames.h caml/prims.h caml/stacks.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/startup_aux.h
-intern_nd.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \
- caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \
- caml/misc.h caml/reverse.h caml/signals.h
-interp_nd.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \
- caml/fix_code.h caml/instrtrace.h caml/instruct.h caml/interp.h \
+ caml/mlvalues.h caml/eventlog.h
+major_gc_nd.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \
+ caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
+ caml/signals.h caml/weak.h caml/memprof.h caml/eventlog.h
+minor_gc_nd.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \
+ caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \
+ caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h \
+ caml/eventlog.h
+memory_nd.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \
caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \
+ caml/memory.h caml/eventlog.h
+alloc_nd.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/stacks.h caml/memory.h caml/signals.h
+compare_nd.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \
+ caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \
- caml/startup_aux.h
+ caml/mlvalues.h
ints_nd.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/misc.h caml/mlvalues.h
+floats_nd.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h
+str_nd.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h
+array_nd.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/signals.h caml/eventlog.h caml/spacetime.h caml/io.h caml/stack.h
io_nd.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
caml/signals.h caml/sys.h
-lexing_nd.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \
+extern_nd.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h
-main_nd.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \
+ caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \
+ caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/misc.h caml/mlvalues.h caml/reverse.h
+intern_nd.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \
+ caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h
-major_gc_nd.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \
- caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
- caml/signals.h caml/weak.h
+ caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \
+ caml/misc.h caml/reverse.h caml/signals.h
+hash_nd.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
+ caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h
+sys_nd.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \
+ caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \
+ caml/startup_aux.h
+parsing_nd.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \
+ caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/alloc.h
+gc_ctrl_nd.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \
+ caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \
+ caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h \
+ caml/eventlog.h caml/stack.h caml/startup_aux.h
+eventlog_nd.$(O): eventlog.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/eventlog.h caml/misc.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/osdeps.h caml/memory.h
md5_nd.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/mlvalues.h caml/io.h caml/reverse.h
-memory_nd.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \
- caml/memory.h
-memprof_nd.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \
- caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \
- caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
- caml/weak.h caml/stack.h caml/misc.h
-meta_nd.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \
- caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \
- caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \
- caml/stacks.h caml/memory.h
-minor_gc_nd.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \
- caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \
- caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h
-misc_nd.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
- caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \
- caml/version.h
obj_nd.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \
caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \
- caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
-parsing_nd.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \
- caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/alloc.h
-prims_nd.$(O): prims.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
- caml/prims.h
+ caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
+lexing_nd.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h
+unix_nd.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
+ caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h
printexc_nd.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \
caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \
caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/memprof.h caml/roots.h caml/memory.h
-roots_byt_nd.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h
-roots_nat_nd.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
+callback_nd.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h
-signals_nd.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/mlvalues.h
+weak_nd.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h caml/eventlog.h
+compact_nd.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \
+ caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h \
+ caml/memprof.h caml/eventlog.h
+finalise_nd.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \
+ caml/roots.h caml/signals.h
+custom_nd.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \
+ caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \
- caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \
- caml/roots.h caml/finalise.h
-signals_byt_nd.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \
- caml/memory.h caml/config.h caml/gc.h caml/mlvalues.h caml/misc.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \
- caml/signals.h caml/signals_machdep.h
-signals_nat_nd.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \
+ caml/domain.h caml/mlvalues.h caml/signals.h
+globroots_nd.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \
+ caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/roots.h caml/memory.h caml/globroots.h caml/roots.h
+backtrace_nat_nd.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \
caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \
+ caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
+ caml/mlvalues.h caml/stack.h
+backtrace_nd.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \
+ caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h
+dynlink_nat_nd.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \
- signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \
- caml/memprof.h caml/roots.h caml/finalise.h
-spacetime_byt_nd.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/mlvalues.h
+ caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \
+ caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h
+debugger_nd.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h
+meta_nd.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \
+ caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \
+ caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \
+ caml/stacks.h caml/memory.h
+dynlink_nd.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
+ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
+ caml/memory.h caml/prims.h caml/signals.h
+clambda_checks_nd.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \
+ caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl
spacetime_nat_nd.$(O): spacetime_nat.c caml/config.h caml/m.h caml/s.h \
caml/alloc.h caml/misc.h caml/config.h caml/mlvalues.h \
caml/domain_state.h caml/domain_state.tbl caml/backtrace_prim.h \
caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
caml/memory.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \
caml/stack.h
-stacks_nd.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \
+afl_nd.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h
+bigarray_nd.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \
+ caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/signals.h
+memprof_nd.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \
+ caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \
+ caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
+ caml/weak.h caml/stack.h caml/misc.h caml/compact.h caml/printexc.h \
+ caml/eventlog.h
+domain_nd.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h
-startup_aux_nd.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \
+win32_nd.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \
+ caml/sys.h caml/config.h
+startup_aux_ni.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \
caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/callback.h caml/major_gc.h caml/osdeps.h \
- caml/memory.h caml/startup_aux.h
-startup_byt_nd.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \
- caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h caml/exec.h \
- caml/fail.h caml/fix_code.h caml/freelist.h caml/gc_ctrl.h \
- caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h caml/io.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/minor_gc.h caml/misc.h \
- caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h caml/printexc.h \
- caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h caml/startup.h \
- caml/startup_aux.h caml/version.h
-startup_nat_nd.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \
+ caml/memory.h caml/startup_aux.h caml/memprof.h caml/roots.h
+startup_nat_ni.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \
caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \
- caml/debugger.h caml/domain.h caml/fail.h caml/freelist.h caml/gc.h \
- caml/gc_ctrl.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/printexc.h caml/stack.h caml/startup_aux.h caml/sys.h
-str_nd.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h
-sys_nd.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \
- caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \
- caml/startup_aux.h
-unix_nd.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/debugger.h caml/domain.h caml/eventlog.h caml/fail.h \
+ caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/intext.h caml/io.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
- caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h
-weak_nd.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h
-win32_nd.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \
- caml/sys.h caml/config.h
-afl_ni.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/osdeps.h caml/memory.h caml/printexc.h caml/stack.h \
+ caml/startup_aux.h caml/sys.h
+main_ni.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \
+ caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h
-alloc_ni.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/stacks.h caml/memory.h caml/signals.h
-array_ni.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
- caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
-backtrace_ni.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+fail_nat_ni.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \
- caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h
-backtrace_byt_ni.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
- caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \
- caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \
- caml/fix_code.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \
- caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \
- caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h
-backtrace_nat_ni.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \
- caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h caml/stack.h
-bigarray_ni.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \
+ caml/stack.h caml/roots.h caml/memory.h caml/callback.h
+roots_nat_ni.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \
+ caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
+ caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h \
+ caml/eventlog.h
+signals_ni.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \
- caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/signals.h
-callback_ni.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \
+ caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \
+ caml/roots.h caml/finalise.h
+signals_nat_ni.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \
+ caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/mlvalues.h
-clambda_checks_ni.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \
- caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl
-compact_ni.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+ caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \
+ signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \
+ caml/memprof.h caml/roots.h caml/finalise.h
+misc_ni.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
+ caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \
+ caml/version.h
+freelist_ni.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \
+ caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \
+ caml/mlvalues.h caml/eventlog.h
+major_gc_ni.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \
caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \
- caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h
+ caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \
+ caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
+ caml/signals.h caml/weak.h caml/memprof.h caml/eventlog.h
+minor_gc_ni.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \
+ caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \
+ caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h \
+ caml/eventlog.h
+memory_ni.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \
+ caml/memory.h caml/eventlog.h
+alloc_ni.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/stacks.h caml/memory.h caml/signals.h
compare_ni.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \
caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
caml/mlvalues.h
-custom_ni.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \
+ints_ni.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
+ caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/mlvalues.h caml/signals.h
-debugger_ni.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h
-domain_ni.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h
+floats_ni.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h
+str_ni.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h
-dynlink_ni.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \
+ caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h
+array_ni.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
- caml/memory.h caml/prims.h caml/signals.h
-dynlink_nat_ni.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \
- caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/signals.h caml/eventlog.h caml/spacetime.h caml/io.h caml/stack.h
+io_ni.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
+ caml/signals.h caml/sys.h
extern_ni.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \
caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/misc.h caml/mlvalues.h caml/reverse.h
-fail_byt_ni.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \
- caml/stacks.h caml/memory.h
-fail_nat_ni.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+intern_ni.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \
+ caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \
+ caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \
- caml/stack.h caml/roots.h caml/memory.h caml/callback.h
-finalise_ni.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \
- caml/roots.h caml/signals.h
-fix_code_ni.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \
- caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \
+ caml/misc.h caml/reverse.h caml/signals.h
+hash_ni.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
+ caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h
+sys_ni.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \
+ caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/misc.h caml/mlvalues.h caml/reverse.h
-floats_ni.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h
-freelist_ni.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \
- caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \
- caml/mlvalues.h
+ caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \
+ caml/startup_aux.h
+parsing_ni.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \
+ caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/alloc.h
gc_ctrl_ni.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \
caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h caml/stack.h \
- caml/startup_aux.h
-globroots_ni.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \
- caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
- caml/roots.h caml/memory.h caml/globroots.h caml/roots.h
-hash_ni.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
- caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h
-instrtrace_ni.$(O): instrtrace.c
-intern_ni.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \
- caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \
- caml/misc.h caml/reverse.h caml/signals.h
-interp_ni.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \
- caml/fix_code.h caml/instrtrace.h caml/instruct.h caml/interp.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \
- caml/startup_aux.h caml/jumptbl.h
-ints_ni.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
- caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h
-io_ni.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/signals.h caml/sys.h
-lexing_ni.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \
+ caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h \
+ caml/eventlog.h caml/stack.h caml/startup_aux.h
+eventlog_ni.$(O): eventlog.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h
-main_ni.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h
-major_gc_ni.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \
- caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
- caml/signals.h caml/weak.h
+ caml/eventlog.h caml/misc.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/osdeps.h caml/memory.h
md5_ni.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/mlvalues.h caml/io.h caml/reverse.h
-memory_ni.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \
- caml/memory.h
-memprof_ni.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \
- caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \
- caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
- caml/weak.h caml/stack.h caml/misc.h
-meta_ni.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \
- caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \
- caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \
- caml/stacks.h caml/memory.h
-minor_gc_ni.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \
- caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \
- caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h
-misc_ni.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
- caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \
- caml/version.h
obj_ni.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \
caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \
caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
-parsing_ni.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \
- caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/alloc.h
-prims_ni.$(O): prims.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
- caml/prims.h
+lexing_ni.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h
+unix_ni.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
+ caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h
printexc_ni.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \
caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \
caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/memprof.h caml/roots.h caml/memory.h
-roots_byt_ni.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h
-roots_nat_ni.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
+callback_ni.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h
-signals_ni.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/mlvalues.h
+weak_ni.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h caml/eventlog.h
+compact_ni.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \
+ caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h \
+ caml/memprof.h caml/eventlog.h
+finalise_ni.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \
+ caml/roots.h caml/signals.h
+custom_ni.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \
+ caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \
- caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \
- caml/roots.h caml/finalise.h
-signals_byt_ni.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \
- caml/memory.h caml/config.h caml/gc.h caml/mlvalues.h caml/misc.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \
- caml/signals.h caml/signals_machdep.h
-signals_nat_ni.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \
- signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \
- caml/memprof.h caml/roots.h caml/finalise.h
-spacetime_byt_ni.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \
+ caml/domain.h caml/mlvalues.h caml/signals.h
+globroots_ni.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \
+ caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/roots.h caml/memory.h caml/globroots.h caml/roots.h
+backtrace_nat_ni.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \
caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/mlvalues.h
+ caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \
+ caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
+ caml/mlvalues.h caml/stack.h
+backtrace_ni.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \
+ caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h
+dynlink_nat_ni.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \
+ caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h
+debugger_ni.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h
+meta_ni.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \
+ caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \
+ caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \
+ caml/stacks.h caml/memory.h
+dynlink_ni.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
+ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
+ caml/memory.h caml/prims.h caml/signals.h
+clambda_checks_ni.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \
+ caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl
spacetime_nat_ni.$(O): spacetime_nat.c caml/config.h caml/m.h caml/s.h \
caml/alloc.h caml/misc.h caml/config.h caml/mlvalues.h \
caml/domain_state.h caml/domain_state.tbl caml/backtrace_prim.h \
caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
caml/memory.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \
caml/stack.h
-stacks_ni.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h
-startup_aux_ni.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \
- caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/callback.h caml/major_gc.h caml/osdeps.h \
- caml/memory.h caml/startup_aux.h
-startup_byt_ni.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \
- caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h caml/exec.h \
- caml/fail.h caml/fix_code.h caml/freelist.h caml/gc_ctrl.h \
- caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h caml/io.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/minor_gc.h caml/misc.h \
- caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h caml/printexc.h \
- caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h caml/startup.h \
- caml/startup_aux.h caml/version.h
-startup_nat_ni.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \
- caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \
- caml/debugger.h caml/domain.h caml/fail.h caml/freelist.h caml/gc.h \
- caml/gc_ctrl.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/printexc.h caml/stack.h caml/startup_aux.h caml/sys.h
-str_ni.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h
-sys_ni.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \
- caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \
- caml/startup_aux.h
-unix_ni.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
- caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h
-weak_ni.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h
-win32_ni.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \
- caml/sys.h caml/config.h
-afl_npic.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
+afl_ni.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h
-alloc_npic.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/stacks.h caml/memory.h caml/signals.h
-array_npic.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
- caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
-backtrace_npic.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \
- caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h
-backtrace_byt_npic.$(O): backtrace_byt.c caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
- caml/mlvalues.h caml/domain_state.tbl caml/alloc.h caml/custom.h \
- caml/io.h caml/instruct.h caml/intext.h caml/io.h caml/exec.h \
- caml/fix_code.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/startup.h \
- caml/exec.h caml/stacks.h caml/memory.h caml/sys.h caml/backtrace.h \
- caml/fail.h caml/backtrace_prim.h caml/backtrace.h caml/debugger.h
-backtrace_nat_npic.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \
- caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h caml/stack.h
-bigarray_npic.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+bigarray_ni.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \
caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
caml/signals.h
-callback_npic.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/mlvalues.h
-clambda_checks_npic.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \
- caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl
-compact_npic.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \
- caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h
-compare_npic.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \
- caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h
-custom_npic.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/mlvalues.h caml/signals.h
-debugger_npic.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h
-domain_npic.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \
+memprof_ni.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \
+ caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \
+ caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
+ caml/weak.h caml/stack.h caml/misc.h caml/compact.h caml/printexc.h \
+ caml/eventlog.h
+domain_ni.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h
-dynlink_npic.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \
+win32_ni.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/osdeps.h caml/memory.h caml/signals.h \
+ caml/sys.h caml/config.h
+startup_aux_npic.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \
+ caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/callback.h caml/major_gc.h caml/osdeps.h \
+ caml/memory.h caml/startup_aux.h caml/memprof.h caml/roots.h
+startup_nat_npic.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \
+ caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \
+ caml/debugger.h caml/domain.h caml/eventlog.h caml/fail.h \
+ caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/intext.h caml/io.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
- caml/memory.h caml/prims.h caml/signals.h
-dynlink_nat_npic.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/osdeps.h caml/memory.h caml/printexc.h caml/stack.h \
+ caml/startup_aux.h caml/sys.h
+main_npic.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \
- caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h
-extern_npic.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \
- caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/misc.h caml/mlvalues.h caml/reverse.h
-fail_byt_npic.$(O): fail_byt.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/fail.h caml/gc.h caml/io.h caml/memory.h caml/gc.h \
+ caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/printexc.h caml/signals.h \
- caml/stacks.h caml/memory.h
+ caml/domain.h
fail_nat_npic.$(O): fail_nat.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/domain.h caml/fail.h caml/io.h caml/gc.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/mlvalues.h caml/printexc.h caml/signals.h \
caml/stack.h caml/roots.h caml/memory.h caml/callback.h
-finalise_npic.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \
- caml/roots.h caml/signals.h
-fix_code_npic.$(O): fix_code.c caml/config.h caml/m.h caml/s.h caml/debugger.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/fix_code.h caml/instruct.h caml/intext.h \
- caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
+roots_nat_npic.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \
+ caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
+ caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/misc.h caml/mlvalues.h caml/reverse.h
-floats_npic.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h \
+ caml/eventlog.h
+signals_npic.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h
+ caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \
+ caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \
+ caml/roots.h caml/finalise.h
+signals_nat_npic.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \
+ caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \
+ signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \
+ caml/memprof.h caml/roots.h caml/finalise.h
+misc_npic.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
+ caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \
+ caml/version.h
freelist_npic.$(O): freelist.c caml/config.h caml/m.h caml/s.h caml/custom.h \
caml/mlvalues.h caml/config.h caml/misc.h caml/domain_state.h \
caml/domain_state.tbl caml/freelist.h caml/gc.h caml/gc_ctrl.h \
caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
caml/address_class.h caml/domain.h caml/major_gc.h caml/misc.h \
- caml/mlvalues.h
-gc_ctrl_npic.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \
- caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h caml/stack.h \
- caml/startup_aux.h
-globroots_npic.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \
- caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
- caml/roots.h caml/memory.h caml/globroots.h caml/roots.h
-hash_npic.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
- caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h
-instrtrace_npic.$(O): instrtrace.c
-intern_npic.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \
- caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \
- caml/misc.h caml/reverse.h caml/signals.h
-interp_npic.$(O): interp.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
- caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace.h caml/exec.h caml/callback.h caml/debugger.h caml/fail.h \
- caml/fix_code.h caml/instrtrace.h caml/instruct.h caml/interp.h \
+ caml/mlvalues.h caml/eventlog.h
+major_gc_npic.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \
+ caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
+ caml/signals.h caml/weak.h caml/memprof.h caml/eventlog.h
+minor_gc_npic.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \
+ caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \
+ caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h \
+ caml/eventlog.h
+memory_npic.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
+ caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \
+ caml/memory.h caml/eventlog.h
+alloc_npic.$(O): alloc.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/stacks.h caml/memory.h caml/signals.h
+compare_npic.$(O): compare.c caml/custom.h caml/mlvalues.h caml/config.h caml/m.h \
+ caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
- caml/mlvalues.h caml/prims.h caml/signals.h caml/stacks.h caml/memory.h \
- caml/startup_aux.h caml/jumptbl.h
+ caml/mlvalues.h
ints_npic.$(O): ints.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/custom.h \
caml/fail.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/misc.h caml/mlvalues.h
+floats_npic.$(O): floats.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/misc.h caml/reverse.h caml/stacks.h caml/memory.h
+str_npic.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h
+array_npic.$(O): array.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/signals.h caml/eventlog.h caml/spacetime.h caml/io.h caml/stack.h
io_npic.$(O): io.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/custom.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
caml/signals.h caml/sys.h
-lexing_npic.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \
+extern_npic.$(O): extern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h
-main_npic.$(O): main.c caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/sys.h caml/osdeps.h caml/memory.h caml/gc.h \
+ caml/config.h caml/custom.h caml/fail.h caml/gc.h caml/intext.h \
+ caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/misc.h caml/mlvalues.h caml/reverse.h
+intern_npic.$(O): intern.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/callback.h caml/config.h caml/custom.h caml/fail.h caml/gc.h \
+ caml/intext.h caml/io.h caml/io.h caml/md5.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h
-major_gc_npic.$(O): major_gc.c caml/compact.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/custom.h caml/config.h caml/fail.h caml/finalise.h caml/roots.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/freelist.h caml/gc.h \
- caml/gc_ctrl.h caml/major_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
- caml/signals.h caml/weak.h
+ caml/domain.h caml/memprof.h caml/roots.h caml/memory.h caml/mlvalues.h \
+ caml/misc.h caml/reverse.h caml/signals.h
+hash_npic.$(O): hash.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
+ caml/custom.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/hash.h
+sys_npic.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \
+ caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \
+ caml/startup_aux.h
+parsing_npic.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \
+ caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/alloc.h
+gc_ctrl_npic.$(O): gc_ctrl.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/backtrace.h caml/exec.h caml/compact.h caml/custom.h caml/fail.h \
+ caml/finalise.h caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h caml/memory.h \
+ caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/signals.h \
+ caml/eventlog.h caml/stack.h caml/startup_aux.h
+eventlog_npic.$(O): eventlog.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/eventlog.h caml/misc.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/osdeps.h caml/memory.h
md5_npic.$(O): md5.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
caml/md5.h caml/io.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/mlvalues.h caml/io.h caml/reverse.h
-memory_npic.$(O): memory.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/fail.h caml/freelist.h caml/gc.h caml/gc_ctrl.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/signals.h caml/memprof.h caml/roots.h \
- caml/memory.h
-memprof_npic.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
- caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \
- caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \
- caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
- caml/weak.h caml/stack.h caml/misc.h
-meta_npic.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \
- caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \
- caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \
- caml/stacks.h caml/memory.h
-minor_gc_npic.$(O): minor_gc.c caml/custom.h caml/mlvalues.h caml/config.h \
- caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
- caml/config.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
- caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/gc.h caml/gc_ctrl.h \
- caml/major_gc.h caml/memory.h caml/minor_gc.h caml/misc.h \
- caml/mlvalues.h caml/roots.h caml/signals.h caml/weak.h caml/memprof.h
-misc_npic.$(O): misc.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
- caml/memory.h caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/osdeps.h caml/memory.h \
- caml/version.h
obj_npic.$(O): obj.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
caml/gc.h caml/interp.h caml/major_gc.h caml/freelist.h caml/memory.h \
caml/gc.h caml/major_gc.h caml/minor_gc.h caml/address_class.h \
caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h \
caml/signals.h caml/spacetime.h caml/io.h caml/stack.h
-parsing_npic.$(O): parsing.c caml/config.h caml/m.h caml/s.h caml/mlvalues.h \
- caml/config.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
- caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/alloc.h
-prims_npic.$(O): prims.c caml/mlvalues.h caml/config.h caml/m.h caml/s.h \
- caml/misc.h caml/domain_state.h caml/mlvalues.h caml/domain_state.tbl \
- caml/prims.h
+lexing_npic.$(O): lexing.c caml/fail.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/mlvalues.h caml/stacks.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h
+unix_npic.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \
+ caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
+ caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h
printexc_npic.$(O): printexc.c caml/backtrace.h caml/mlvalues.h caml/config.h \
caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
caml/exec.h caml/callback.h caml/debugger.h caml/fail.h caml/misc.h \
caml/mlvalues.h caml/printexc.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
caml/memprof.h caml/roots.h caml/memory.h
-roots_byt_npic.$(O): roots_byt.c caml/finalise.h caml/roots.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/globroots.h caml/major_gc.h caml/memory.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/roots.h caml/stacks.h caml/memprof.h
-roots_nat_npic.$(O): roots_nat.c caml/finalise.h caml/roots.h caml/misc.h \
- caml/config.h caml/m.h caml/s.h caml/memory.h caml/gc.h caml/mlvalues.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
+callback_npic.$(O): callback.c caml/callback.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/domain.h caml/fail.h caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/globroots.h caml/memory.h caml/major_gc.h caml/minor_gc.h \
- caml/misc.h caml/mlvalues.h caml/stack.h caml/roots.h caml/memprof.h
-signals_npic.$(O): signals.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/mlvalues.h
+weak_npic.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
+ caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
+ caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h caml/eventlog.h
+compact_npic.$(O): compact.c caml/address_class.h caml/config.h caml/m.h caml/s.h \
+ caml/misc.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/finalise.h caml/roots.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
+ caml/domain.h caml/freelist.h caml/gc.h caml/gc_ctrl.h caml/major_gc.h \
+ caml/memory.h caml/mlvalues.h caml/roots.h caml/weak.h caml/compact.h \
+ caml/memprof.h caml/eventlog.h
+finalise_npic.$(O): finalise.c caml/callback.h caml/mlvalues.h caml/config.h \
+ caml/m.h caml/s.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/compact.h caml/fail.h caml/finalise.h caml/roots.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/minor_gc.h caml/mlvalues.h \
+ caml/roots.h caml/signals.h
+custom_npic.$(O): custom.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/callback.h caml/config.h caml/fail.h caml/memory.h caml/gc.h \
+ caml/custom.h caml/fail.h caml/gc_ctrl.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/roots.h caml/memory.h \
- caml/signals.h caml/signals_machdep.h caml/sys.h caml/memprof.h \
- caml/roots.h caml/finalise.h
-signals_byt_npic.$(O): signals_byt.c caml/config.h caml/m.h caml/s.h \
- caml/memory.h caml/config.h caml/gc.h caml/mlvalues.h caml/misc.h \
- caml/domain_state.h caml/domain_state.tbl caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/fail.h caml/finalise.h caml/roots.h caml/memory.h caml/osdeps.h \
- caml/signals.h caml/signals_machdep.h
-signals_nat_npic.$(O): signals_nat.c caml/fail.h caml/misc.h caml/config.h \
+ caml/domain.h caml/mlvalues.h caml/signals.h
+globroots_npic.$(O): globroots.c caml/memory.h caml/config.h caml/m.h caml/s.h \
+ caml/gc.h caml/mlvalues.h caml/misc.h caml/domain_state.h \
+ caml/domain_state.tbl caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/mlvalues.h \
+ caml/roots.h caml/memory.h caml/globroots.h caml/roots.h
+backtrace_nat_npic.$(O): backtrace_nat.c caml/alloc.h caml/misc.h caml/config.h \
caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/backtrace_prim.h \
+ caml/backtrace.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/misc.h \
+ caml/mlvalues.h caml/stack.h
+backtrace_npic.$(O): backtrace.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/backtrace.h caml/exec.h \
+ caml/backtrace_prim.h caml/backtrace.h caml/fail.h caml/debugger.h
+dynlink_nat_npic.$(O): dynlink_nat.c caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
caml/domain_state.tbl caml/memory.h caml/gc.h caml/major_gc.h \
caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/osdeps.h caml/memory.h caml/signals.h caml/signals_machdep.h \
- signals_osdep.h caml/stack.h caml/spacetime.h caml/io.h caml/stack.h \
- caml/memprof.h caml/roots.h caml/finalise.h
-spacetime_byt_npic.$(O): spacetime_byt.c caml/fail.h caml/misc.h caml/config.h \
- caml/m.h caml/s.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/mlvalues.h
+ caml/stack.h caml/callback.h caml/alloc.h caml/intext.h caml/io.h \
+ caml/osdeps.h caml/memory.h caml/fail.h caml/signals.h caml/hooks.h
+debugger_npic.$(O): debugger.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/config.h caml/debugger.h caml/misc.h caml/osdeps.h caml/memory.h \
+ caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h
+meta_npic.$(O): meta.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/backtrace_prim.h caml/backtrace.h caml/exec.h caml/config.h \
+ caml/debugger.h caml/fail.h caml/fix_code.h caml/interp.h caml/intext.h \
+ caml/io.h caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h \
+ caml/major_gc.h caml/minor_gc.h caml/address_class.h caml/domain.h \
+ caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/prims.h caml/signals.h \
+ caml/stacks.h caml/memory.h
+dynlink_npic.$(O): dynlink.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
+ caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
+ caml/domain_state.tbl caml/dynlink.h caml/fail.h caml/mlvalues.h \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
+ caml/memory.h caml/prims.h caml/signals.h
+clambda_checks_npic.$(O): clambda_checks.c caml/mlvalues.h caml/config.h caml/m.h \
+ caml/s.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl
spacetime_nat_npic.$(O): spacetime_nat.c caml/config.h caml/m.h caml/s.h \
caml/alloc.h caml/misc.h caml/config.h caml/mlvalues.h \
caml/domain_state.h caml/domain_state.tbl caml/backtrace_prim.h \
caml/domain.h caml/minor_gc.h caml/misc.h caml/mlvalues.h caml/roots.h \
caml/memory.h caml/signals.h caml/stack.h caml/sys.h caml/spacetime.h \
caml/stack.h
-stacks_npic.$(O): stacks.c caml/config.h caml/m.h caml/s.h caml/fail.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/misc.h caml/mlvalues.h caml/stacks.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h
-startup_aux_npic.$(O): startup_aux.c caml/backtrace.h caml/mlvalues.h \
- caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/exec.h caml/memory.h caml/gc.h \
- caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/callback.h caml/major_gc.h caml/osdeps.h \
- caml/memory.h caml/startup_aux.h
-startup_byt_npic.$(O): startup_byt.c caml/config.h caml/m.h caml/s.h caml/alloc.h \
- caml/misc.h caml/config.h caml/mlvalues.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/callback.h \
- caml/custom.h caml/debugger.h caml/domain.h caml/dynlink.h caml/exec.h \
- caml/fail.h caml/fix_code.h caml/freelist.h caml/gc_ctrl.h \
- caml/instrtrace.h caml/interp.h caml/intext.h caml/io.h caml/io.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/minor_gc.h caml/misc.h \
- caml/mlvalues.h caml/osdeps.h caml/memory.h caml/prims.h caml/printexc.h \
- caml/reverse.h caml/signals.h caml/stacks.h caml/sys.h caml/startup.h \
- caml/startup_aux.h caml/version.h
-startup_nat_npic.$(O): startup_nat.c caml/callback.h caml/mlvalues.h \
- caml/config.h caml/m.h caml/s.h caml/misc.h caml/domain_state.h \
- caml/domain_state.tbl caml/backtrace.h caml/exec.h caml/custom.h \
- caml/debugger.h caml/domain.h caml/fail.h caml/freelist.h caml/gc.h \
- caml/gc_ctrl.h caml/intext.h caml/io.h caml/memory.h caml/gc.h \
+afl_npic.$(O): afl.c caml/config.h caml/m.h caml/s.h caml/misc.h caml/config.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/mlvalues.h \
+ caml/domain_state.tbl caml/osdeps.h caml/memory.h caml/gc.h \
caml/major_gc.h caml/freelist.h caml/minor_gc.h caml/address_class.h \
- caml/domain.h caml/misc.h caml/mlvalues.h caml/osdeps.h caml/memory.h \
- caml/printexc.h caml/stack.h caml/startup_aux.h caml/sys.h
-str_npic.$(O): str.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/mlvalues.h caml/misc.h
-sys_npic.$(O): sys.c caml/config.h caml/m.h caml/s.h caml/alloc.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/debugger.h caml/fail.h caml/gc_ctrl.h caml/io.h caml/misc.h \
- caml/mlvalues.h caml/osdeps.h caml/memory.h caml/gc.h caml/major_gc.h \
- caml/freelist.h caml/minor_gc.h caml/address_class.h caml/domain.h \
- caml/signals.h caml/stacks.h caml/sys.h caml/version.h caml/callback.h \
- caml/startup_aux.h
-unix_npic.$(O): unix.c caml/config.h caml/m.h caml/s.h caml/fail.h caml/misc.h \
- caml/config.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
- caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
- caml/address_class.h caml/domain.h caml/misc.h caml/osdeps.h \
- caml/memory.h caml/signals.h caml/sys.h caml/io.h caml/alloc.h
-weak_npic.$(O): weak.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
- caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl caml/fail.h \
- caml/major_gc.h caml/freelist.h caml/memory.h caml/gc.h caml/major_gc.h \
+ caml/domain.h
+bigarray_npic.$(O): bigarray.c caml/alloc.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/bigarray.h caml/custom.h caml/fail.h caml/intext.h caml/io.h \
+ caml/hash.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
caml/minor_gc.h caml/address_class.h caml/domain.h caml/mlvalues.h \
- caml/weak.h caml/memory.h caml/minor_gc.h caml/signals.h
+ caml/signals.h
+memprof_npic.$(O): memprof.c caml/memprof.h caml/config.h caml/m.h caml/s.h \
+ caml/mlvalues.h caml/misc.h caml/domain_state.h caml/domain_state.tbl \
+ caml/roots.h caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h \
+ caml/minor_gc.h caml/address_class.h caml/domain.h caml/fail.h \
+ caml/alloc.h caml/callback.h caml/signals.h caml/memory.h \
+ caml/minor_gc.h caml/backtrace_prim.h caml/backtrace.h caml/exec.h \
+ caml/weak.h caml/stack.h caml/misc.h caml/compact.h caml/printexc.h \
+ caml/eventlog.h
+domain_npic.$(O): domain.c caml/domain_state.h caml/misc.h caml/config.h caml/m.h \
+ caml/s.h caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
+ caml/memory.h caml/gc.h caml/major_gc.h caml/freelist.h caml/minor_gc.h \
+ caml/address_class.h caml/domain.h
win32_npic.$(O): win32.c caml/alloc.h caml/misc.h caml/config.h caml/m.h caml/s.h \
caml/mlvalues.h caml/domain_state.h caml/domain_state.tbl \
caml/address_class.h caml/fail.h caml/io.h caml/memory.h caml/gc.h \
ROOTDIR = ..
-include $(ROOTDIR)/Makefile.config
-include $(ROOTDIR)/Makefile.common
+-include $(ROOTDIR)/Makefile.config
+-include $(ROOTDIR)/Makefile.common
# Lists of source files
BYTECODE_C_SOURCES := $(addsuffix .c, \
interp misc stacks fix_code startup_aux startup_byt freelist major_gc \
minor_gc memory alloc roots_byt globroots fail_byt signals \
- signals_byt printexc backtrace_byt backtrace compare ints \
+ signals_byt printexc backtrace_byt backtrace compare ints eventlog \
floats str array io extern intern hash sys meta parsing gc_ctrl md5 obj \
lexing callback debugger weak compact finalise custom dynlink \
spacetime_byt afl $(UNIX_OR_WIN32) bigarray main memprof domain)
NATIVE_C_SOURCES := $(addsuffix .c, \
startup_aux startup_nat main fail_nat roots_nat signals \
signals_nat misc freelist major_gc minor_gc memory alloc compare ints \
- floats str array io extern intern hash sys parsing gc_ctrl md5 obj \
+ floats str array io extern intern hash sys parsing gc_ctrl eventlog md5 obj \
lexing $(UNIX_OR_WIN32) printexc callback weak compact finalise custom \
globroots backtrace_nat backtrace dynlink_nat debugger meta \
dynlink clambda_checks spacetime_nat spacetime_snapshot afl bigarray \
.PHONY: clean
clean:
- rm -f $(PROGRAMS) *.$(O) *.$(A) *.$(SO) ld.conf
- rm -f primitives prims.c caml/opnames.h caml/jumptbl.h
+ rm -f *.o *.obj *.a *.lib *.so *.dll ld.conf
+ rm -f ocamlrun ocamlrund ocamlruni
+ rm -f ocamlrun.exe ocamlrund.exe ocamlruni.exe
+ rm -f primitives primitives.new prims.c caml/opnames.h caml/jumptbl.h
rm -f caml/version.h domain_state*.inc
.PHONY: distclean
echo ' 0 };') > prims.c
caml/opnames.h : caml/instruct.h
- cat $^ | tr -d '\r' | \
+ tr -d '\r' < $< | \
sed -e '/\/\*/d' \
-e '/^#/d' \
-e 's/enum /static char * names_of_/' \
# caml/jumptbl.h is required only if you have GCC 2.0 or later
caml/jumptbl.h : caml/instruct.h
- cat $^ | tr -d '\r' | \
+ tr -d '\r' < $< | \
sed -n -e '/^ /s/ \([A-Z]\)/ \&\&lbl_\1/gp' \
-e '/^}/q' > $@
else
NATIVE_DEP_CPPFLAGS := $(OC_CPPFLAGS) $(OC_NATIVE_CPPFLAGS)
+BYTECODE_DEP_FILES := $(BYTECODE_C_SOURCES) $(other_files) instrtrace.c
NATIVE_DEP_FILES := $(NATIVE_C_SOURCES) $(other_files)
depend: *.c caml/opnames.h caml/jumptbl.h caml/version.h
- $(CC) -MM $(OC_CPPFLAGS) *.c | \
+ $(CC) -MM $(OC_CPPFLAGS) $(BYTECODE_DEP_FILES) | \
sed -e 's/\([^.]*\)\.o/\1_b.$$(O)/' > .depend
- $(CC) -MM $(OC_CPPFLAGS) $(OC_DEBUG_CPPFLAGS) *.c | \
+ $(CC) -MM $(OC_CPPFLAGS) $(OC_DEBUG_CPPFLAGS) \
+ $(BYTECODE_DEP_FILES) | \
sed -e 's/\([^.]*\)\.o/\1_bd.$$(O)/' >> .depend
- $(CC) -MM $(OC_CPPFLAGS) $(OC_INSTR_CPPFLAGS) *.c | \
+ $(CC) -MM $(OC_CPPFLAGS) $(OC_INSTR_CPPFLAGS) \
+ $(BYTECODE_DEP_FILES) | \
sed -e 's/\([^.]*\)\.o/\1_bi.$$(O)/' >> .depend
- $(CC) -MM $(OC_CPPFLAGS) *.c | \
+ $(CC) -MM $(OC_CPPFLAGS) $(BYTECODE_DEP_FILES) | \
sed -e 's/\([^.]*\)\.o/\1_bpic.$$(O)/' >> .depend
- $(CC) -MM $(NATIVE_DEP_CPPFLAGS) *.c | \
+ $(CC) -MM $(NATIVE_DEP_CPPFLAGS) $(NATIVE_DEP_FILES) | \
sed -e 's/\([^.]*\)\.o/\1_n.$$(O)/' >> .depend
- $(CC) -MM $(NATIVE_DEP_CPPFLAGS) $(OC_DEBUG_CPPFLAGS) *.c | \
+ $(CC) -MM $(NATIVE_DEP_CPPFLAGS) $(OC_DEBUG_CPPFLAGS) \
+ $(NATIVE_DEP_FILES) | \
sed -e 's/\([^.]*\)\.o/\1_nd.$$(O)/' >> .depend
- $(CC) -MM $(NATIVE_DEP_CPPFLAGS) $(OC_INSTR_CPPFLAGS) *.c | \
+ $(CC) -MM $(NATIVE_DEP_CPPFLAGS) $(OC_INSTR_CPPFLAGS) \
+ $(NATIVE_DEP_FILES) | \
sed -e 's/\([^.]*\)\.o/\1_ni.$$(O)/' >> .depend
- $(CC) -MM $(NATIVE_DEP_CPPFLAGS) *.c | \
+ $(CC) -MM $(NATIVE_DEP_CPPFLAGS) $(NATIVE_DEP_FILES) | \
sed -e 's/\([^.]*\)\.o/\1_npic.$$(O)/' >> .depend
endif
CAMLprim value caml_setup_afl(value unit)
{
+ char* shm_id_str;
+ char* shm_id_end;
+ long int shm_id;
+ uint32_t startup_msg = 0;
+
if (afl_initialised) return Val_unit;
afl_initialised = 1;
- char* shm_id_str = caml_secure_getenv("__AFL_SHM_ID");
+ shm_id_str = caml_secure_getenv("__AFL_SHM_ID");
if (shm_id_str == NULL) {
/* Not running under afl-fuzz, continue as normal */
return Val_unit;
/* if afl-fuzz is attached, we want it to know about uncaught exceptions */
caml_abort_on_uncaught_exn = 1;
- char* shm_id_end;
- long int shm_id = strtol(shm_id_str, &shm_id_end, 10);
+ shm_id = strtol(shm_id_str, &shm_id_end, 10);
if (!(*shm_id_str != '\0' && *shm_id_end == '\0'))
caml_fatal_error("afl-fuzz: bad shm id");
caml_afl_area_ptr[0] = 1;
/* synchronise with afl-fuzz */
- uint32_t startup_msg = 0;
if (write(FORKSRV_FD_WRITE, &startup_msg, 4) != 4) {
/* initial write failed, so assume we're not meant to fork.
afl-tmin uses this mode. */
/* As long as the child keeps raising SIGSTOP, we re-use the same process */
while (1) {
+ int status;
+ uint32_t was_killed;
+
afl_write((uint32_t)child_pid);
- int status;
/* WUNTRACED means wait until termination or SIGSTOP */
if (waitpid(child_pid, &status, WUNTRACED) < 0)
caml_fatal_error("afl-fuzz: waitpid failed");
afl_write((uint32_t)status);
- uint32_t was_killed = afl_read();
+ was_killed = afl_read();
if (WIFSTOPPED(status)) {
/* child stopped, waiting for another test case */
if (was_killed) {
movq GREL(dstlabel)(%rip), %r11 ; \
popq (%r11); CFI_ADJUST (-8)
-/* Record lowest stack address and return address. Clobbers %rax. */
-#define RECORD_STACK_FRAME(OFFSET) \
- pushq %r11 ; CFI_ADJUST(8); \
- movq 8+OFFSET(%rsp), %rax ; \
- movq %rax, Caml_state(last_return_address) ; \
- leaq 16+OFFSET(%rsp), %rax ; \
- movq %rax, Caml_state(bottom_of_stack) ; \
- popq %r11; CFI_ADJUST(-8)
-
/* Load address of global [label] in register [dst]. */
#define LEA_VAR(label,dst) \
movq GREL(label)(%rip), dst
#define POP_VAR(dstlabel) \
popq G(dstlabel)(%rip); CFI_ADJUST(-8)
-#define RECORD_STACK_FRAME(OFFSET) \
- movq OFFSET(%rsp), %rax ; \
- movq %rax, Caml_state(last_return_address) ; \
- leaq 8+OFFSET(%rsp), %rax ; \
- movq %rax, Caml_state(bottom_of_stack)
-
#define LEA_VAR(label,dst) \
leaq G(label)(%rip), dst
#endif
FUNCTION(G(caml_call_gc))
CFI_STARTPROC
- RECORD_STACK_FRAME(0)
LBL(caml_call_gc):
+ /* Record lowest stack address and return address. */
+ movq (%rsp), %r11
+ movq %r11, Caml_state(last_return_address)
+ leaq 8(%rsp), %r11
+ movq %r11, Caml_state(bottom_of_stack)
/* Touch the stack to trigger a recoverable segfault
if insufficient space remains */
subq $(STACK_PROBE_SIZE), %rsp; CFI_ADJUST(STACK_PROBE_SIZE);
- movq %rax, 0(%rsp)
+ movq %r11, 0(%rsp)
addq $(STACK_PROBE_SIZE), %rsp; CFI_ADJUST(-STACK_PROBE_SIZE);
/* Build array of registers, save it into Caml_state->gc_regs */
#ifdef WITH_FRAME_POINTERS
FUNCTION(G(caml_alloc1))
CFI_STARTPROC
-LBL(caml_alloc1):
subq $16, %r15
cmpq Caml_state(young_limit), %r15
- jb LBL(100)
+ jb LBL(caml_call_gc)
ret
-LBL(100):
- addq $16, %r15
- RECORD_STACK_FRAME(0)
- ENTER_FUNCTION
-/* subq $8, %rsp; CFI_ADJUST (8); */
- call LBL(caml_call_gc)
-/* addq $8, %rsp; CFI_ADJUST (-8); */
- LEAVE_FUNCTION
- jmp LBL(caml_alloc1)
CFI_ENDPROC
ENDFUNCTION(G(caml_alloc1))
FUNCTION(G(caml_alloc2))
CFI_STARTPROC
-LBL(caml_alloc2):
subq $24, %r15
cmpq Caml_state(young_limit), %r15
- jb LBL(101)
+ jb LBL(caml_call_gc)
ret
-LBL(101):
- addq $24, %r15
- RECORD_STACK_FRAME(0)
- ENTER_FUNCTION
-/* subq $8, %rsp; CFI_ADJUST (8); */
- call LBL(caml_call_gc)
-/* addq $8, %rsp; CFI_ADJUST (-8); */
- LEAVE_FUNCTION
- jmp LBL(caml_alloc2)
CFI_ENDPROC
ENDFUNCTION(G(caml_alloc2))
FUNCTION(G(caml_alloc3))
CFI_STARTPROC
-LBL(caml_alloc3):
subq $32, %r15
cmpq Caml_state(young_limit), %r15
- jb LBL(102)
+ jb LBL(caml_call_gc)
ret
-LBL(102):
- addq $32, %r15
- RECORD_STACK_FRAME(0)
- ENTER_FUNCTION
-/* subq $8, %rsp; CFI_ADJUST (8) */
- call LBL(caml_call_gc)
-/* addq $8, %rsp; CFI_ADJUST (-8) */
- LEAVE_FUNCTION
- jmp LBL(caml_alloc3)
CFI_ENDPROC
ENDFUNCTION(G(caml_alloc3))
FUNCTION(G(caml_allocN))
CFI_STARTPROC
-LBL(caml_allocN):
- pushq %rax; CFI_ADJUST(8) /* save desired size */
- subq %rax, %r15
cmpq Caml_state(young_limit), %r15
- jb LBL(103)
- addq $8, %rsp; CFI_ADJUST (-8) /* drop desired size */
+ jb LBL(caml_call_gc)
ret
-LBL(103):
- addq 0(%rsp), %r15
- CFI_ADJUST(8)
- RECORD_STACK_FRAME(8)
-#ifdef WITH_FRAME_POINTERS
- /* ensure 16 byte alignment by subq + enter using 16-bytes, PR#7417 */
- subq $8, %rsp; CFI_ADJUST (8)
- ENTER_FUNCTION
-#endif
- call LBL(caml_call_gc)
-#ifdef WITH_FRAME_POINTERS
- /* ensure 16 byte alignment by leave + addq using 16-bytes PR#7417 */
- LEAVE_FUNCTION
- addq $8, %rsp; CFI_ADJUST (-8)
-#endif
- popq %rax; CFI_ADJUST(-8) /* recover desired size */
- jmp LBL(caml_allocN)
CFI_ENDPROC
ENDFUNCTION(G(caml_allocN))
-/* Reset the allocation pointer and invoke the GC */
-
-FUNCTION(G(caml_call_gc1))
-CFI_STARTPROC
- addq $16, %r15
- jmp GCALL(caml_call_gc)
-CFI_ENDPROC
-
-FUNCTION(G(caml_call_gc2))
-CFI_STARTPROC
- addq $24, %r15
- jmp GCALL(caml_call_gc)
-CFI_ENDPROC
-
-FUNCTION(G(caml_call_gc3))
-CFI_STARTPROC
- addq $32, %r15
- jmp GCALL(caml_call_gc)
-CFI_ENDPROC
-
-
/* Call a C function from OCaml */
FUNCTION(G(caml_c_call))
ALIGN 16
caml_call_gc:
; Record lowest stack address and return address
- mov rax, [rsp]
- Store_last_return_address rax
- lea rax, [rsp+8]
- Store_bottom_of_stack rax
-L105:
+ mov r11, [rsp]
+ Store_last_return_address r11
+ lea r11, [rsp+8]
+ Store_bottom_of_stack r11
; Touch the stack to trigger a recoverable segfault
; if insufficient space remains
sub rsp, 01000h
- mov [rsp], rax
+ mov [rsp], r11
add rsp, 01000h
; Save young_ptr
Store_young_ptr r15
caml_alloc1:
sub r15, 16
Cmp_young_limit r15
- jb L100
+ jb caml_call_gc
ret
-L100:
- add r15, 16
- mov rax, [rsp + 0]
- Store_last_return_address rax
- lea rax, [rsp + 8]
- Store_bottom_of_stack rax
- sub rsp, 8
- call L105
- add rsp, 8
- jmp caml_alloc1
PUBLIC caml_alloc2
ALIGN 16
caml_alloc2:
sub r15, 24
Cmp_young_limit r15
- jb L101
+ jb caml_call_gc
ret
-L101:
- add r15, 24
- mov rax, [rsp + 0]
- Store_last_return_address rax
- lea rax, [rsp + 8]
- Store_bottom_of_stack rax
- sub rsp, 8
- call L105
- add rsp, 8
- jmp caml_alloc2
PUBLIC caml_alloc3
ALIGN 16
caml_alloc3:
sub r15, 32
Cmp_young_limit r15
- jb L102
+ jb caml_call_gc
ret
-L102:
- add r15, 32
- mov rax, [rsp + 0]
- Store_last_return_address rax
- lea rax, [rsp + 8]
- Store_bottom_of_stack rax
- sub rsp, 8
- call L105
- add rsp, 8
- jmp caml_alloc3
PUBLIC caml_allocN
ALIGN 16
caml_allocN:
- sub r15, rax
Cmp_young_limit r15
- jb L103
+ jb caml_call_gc
ret
-L103:
- add r15, rax
- push rax ; save desired size
- mov rax, [rsp + 8]
- Store_last_return_address rax
- lea rax, [rsp + 16]
- Store_bottom_of_stack rax
- call L105
- pop rax ; recover desired size
- jmp caml_allocN
-
-; Reset the allocation pointer and invoke the GC
-
- PUBLIC caml_call_gc1
- ALIGN 16
-caml_call_gc1:
- add r15, 16
- jmp caml_call_gc
-
- PUBLIC caml_call_gc2
- ALIGN 16
-caml_call_gc2:
- add r15, 24
- jmp caml_call_gc
-
- PUBLIC caml_call_gc3
- ALIGN 16
-caml_call_gc3:
- add r15, 32
- jmp caml_call_gc
; Call a C function from OCaml
FUNCTION(caml_call_gc)
CFI_STARTPROC
+.Lcaml_call_gc:
/* Record return address */
str lr, Caml_state(last_return_address)
-.Lcaml_call_gc:
/* Record lowest stack address */
str sp, Caml_state(bottom_of_stack)
#if defined(SYS_linux_eabihf) || defined(SYS_netbsd)
FUNCTION(caml_alloc1)
CFI_STARTPROC
-.Lcaml_alloc1:
sub alloc_ptr, alloc_ptr, 8
ldr r7, Caml_state(young_limit)
cmp alloc_ptr, r7
- bcc 1f
+ bcc .Lcaml_call_gc
bx lr
-1: add alloc_ptr, alloc_ptr, 8
- /* Record return address */
- str lr, Caml_state(last_return_address)
- /* Call GC */
- bl .Lcaml_call_gc
- /* Restore return address */
- ldr lr, Caml_state(last_return_address)
- /* Try again */
- b .Lcaml_alloc1
CFI_ENDPROC
.size caml_alloc1, .-caml_alloc1
FUNCTION(caml_alloc2)
CFI_STARTPROC
-.Lcaml_alloc2:
sub alloc_ptr, alloc_ptr, 12
ldr r7, Caml_state(young_limit)
cmp alloc_ptr, r7
- bcc 1f
+ bcc .Lcaml_call_gc
bx lr
-1: add alloc_ptr, alloc_ptr, 12
- /* Record return address */
- str lr, Caml_state(last_return_address)
- /* Call GC */
- bl .Lcaml_call_gc
- /* Restore return address */
- ldr lr, Caml_state(last_return_address)
- /* Try again */
- b .Lcaml_alloc2
CFI_ENDPROC
.size caml_alloc2, .-caml_alloc2
FUNCTION(caml_alloc3)
CFI_STARTPROC
-.Lcaml_alloc3:
sub alloc_ptr, alloc_ptr, 16
ldr r7, Caml_state(young_limit)
cmp alloc_ptr, r7
- bcc 1f
+ bcc .Lcaml_call_gc
bx lr
-1: add alloc_ptr, alloc_ptr, 16
- /* Record return address */
- str lr, Caml_state(last_return_address)
- /* Call GC */
- bl .Lcaml_call_gc
- /* Restore return address */
- ldr lr, Caml_state(last_return_address)
- /* Try again */
- b .Lcaml_alloc3
CFI_ENDPROC
.size caml_alloc3, .-caml_alloc3
FUNCTION(caml_allocN)
CFI_STARTPROC
-.Lcaml_allocN:
sub alloc_ptr, alloc_ptr, r7
- ldr r12, Caml_state(young_limit)
- cmp alloc_ptr, r12
- bcc 1f
+ ldr r7, Caml_state(young_limit)
+ cmp alloc_ptr, r7
+ bcc .Lcaml_call_gc
bx lr
-1: add alloc_ptr, alloc_ptr, r7
- /* Record return address */
- str lr, Caml_state(last_return_address)
- /* Call GC (preserves r7) */
- bl .Lcaml_call_gc
- /* Restore return address */
- ldr lr, Caml_state(last_return_address)
- /* Try again */
- b .Lcaml_allocN
CFI_ENDPROC
.size caml_allocN, .-caml_allocN
FUNCTION(caml_call_gc)
CFI_STARTPROC
+.Lcaml_call_gc:
/* Record return address */
str x30, Caml_state(last_return_address)
/* Record lowest stack address */
mov TMP, sp
str TMP, Caml_state(bottom_of_stack)
-.Lcaml_call_gc:
/* Set up stack space, saving return address and frame pointer */
/* (2 regs RA/GP, 24 allocatable int regs, 24 caller-save float regs) * 8 */
CFI_OFFSET(29, -400)
FUNCTION(caml_alloc1)
CFI_STARTPROC
-1: sub ALLOC_PTR, ALLOC_PTR, #16
+ sub ALLOC_PTR, ALLOC_PTR, #16
cmp ALLOC_PTR, ALLOC_LIMIT
- b.lo 2f
+ b.lo .Lcaml_call_gc
ret
-2: add ALLOC_PTR, ALLOC_PTR, #16
- stp x29, x30, [sp, -16]!
- CFI_ADJUST(16)
- /* Record the lowest address of the caller's stack frame. This is the
- address immediately above the pair of words (x29 and x30) we just
- pushed. Those must not be included since otherwise the distance from
- [Caml_state->bottom_of_stack] to the highest address in the caller's
- stack frame won't match the frame size contained in the relevant
- frame descriptor. */
- add x29, sp, #16
- str x29, Caml_state(bottom_of_stack)
- add x29, sp, #0
- /* Record return address */
- str x30, Caml_state(last_return_address)
- /* Call GC */
- bl .Lcaml_call_gc
- /* Restore return address */
- ldp x29, x30, [sp], 16
- CFI_ADJUST(-16)
- /* Try again */
- b 1b
CFI_ENDPROC
- .type caml_alloc1, %function
.size caml_alloc1, .-caml_alloc1
- .align 2
- .globl caml_alloc2
-caml_alloc2:
+FUNCTION(caml_alloc2)
CFI_STARTPROC
-1: sub ALLOC_PTR, ALLOC_PTR, #24
+ sub ALLOC_PTR, ALLOC_PTR, #24
cmp ALLOC_PTR, ALLOC_LIMIT
- b.lo 2f
+ b.lo .Lcaml_call_gc
ret
-2: add ALLOC_PTR, ALLOC_PTR, #24
- stp x29, x30, [sp, -16]!
- CFI_ADJUST(16)
- /* Record the lowest address of the caller's stack frame.
- See comment above. */
- add x29, sp, #16
- str x29, Caml_state(bottom_of_stack)
- add x29, sp, #0
- /* Record return address */
- str x30, Caml_state(last_return_address)
- /* Call GC */
- bl .Lcaml_call_gc
- /* Restore return address */
- ldp x29, x30, [sp], 16
- CFI_ADJUST(-16)
- /* Try again */
- b 1b
CFI_ENDPROC
- .type caml_alloc2, %function
.size caml_alloc2, .-caml_alloc2
FUNCTION(caml_alloc3)
CFI_STARTPROC
-1: sub ALLOC_PTR, ALLOC_PTR, #32
+ sub ALLOC_PTR, ALLOC_PTR, #32
cmp ALLOC_PTR, ALLOC_LIMIT
- b.lo 2f
+ b.lo .Lcaml_call_gc
ret
-2: add ALLOC_PTR, ALLOC_PTR, #32
- stp x29, x30, [sp, -16]!
- CFI_ADJUST(16)
- /* Record the lowest address of the caller's stack frame.
- See comment above. */
- add x29, sp, #16
- str x29, Caml_state(bottom_of_stack)
- add x29, sp, #0
- /* Record return address */
- str x30, Caml_state(last_return_address)
- /* Call GC */
- bl .Lcaml_call_gc
- /* Restore return address */
- ldp x29, x30, [sp], 16
- CFI_ADJUST(-16)
- /* Try again */
- b 1b
CFI_ENDPROC
- .type caml_alloc3, %function
.size caml_alloc3, .-caml_alloc3
- TEXT_SECTION(caml_allocN)
- .align 2
- .globl caml_allocN
-caml_allocN:
+FUNCTION(caml_allocN)
CFI_STARTPROC
-1: sub ALLOC_PTR, ALLOC_PTR, ARG
+ sub ALLOC_PTR, ALLOC_PTR, ARG
cmp ALLOC_PTR, ALLOC_LIMIT
- b.lo 2f
+ b.lo .Lcaml_call_gc
ret
-2: add ALLOC_PTR, ALLOC_PTR, ARG
- stp x29, x30, [sp, -16]!
- CFI_ADJUST(16)
- /* Record the lowest address of the caller's stack frame.
- See comment above. */
- add x29, sp, #16
- str x29, Caml_state(bottom_of_stack)
- add x29, sp, #0
- /* Record return address */
- str x30, Caml_state(last_return_address)
- /* Call GC. This preserves ARG */
- bl .Lcaml_call_gc
- /* Restore return address */
- ldp x29, x30, [sp], 16
- CFI_ADJUST(-16)
- /* Try again */
- b 1b
CFI_ENDPROC
.size caml_allocN, .-caml_allocN
#include "caml/misc.h"
#include "caml/mlvalues.h"
#include "caml/signals.h"
+#include "caml/eventlog.h"
/* Why is caml/spacetime.h included conditionnally sometimes and not here ? */
#include "caml/spacetime.h"
if (Is_block(init) && Is_young(init)) {
/* We don't want to create so many major-to-minor references,
so [init] is moved to the major heap by doing a minor GC. */
- CAML_INSTR_INT ("force_minor/make_vect@", 1);
+ CAML_EV_COUNTER (EV_C_FORCE_MINOR_MAKE_VECT, 1);
caml_minor_collection ();
}
CAMLassert(!(Is_block(init) && Is_young(init)));
if (! li->loc_valid) {
fprintf(stderr, "%s unknown location%s\n", info, inlined);
} else {
- fprintf (stderr, "%s file \"%s\"%s, line %d, characters %d-%d\n",
- info, li->loc_filename, inlined, li->loc_lnum,
+ fprintf (stderr, "%s %s in file \"%s\"%s, line %d, characters %d-%d\n",
+ info, li->loc_defname, li->loc_filename, inlined, li->loc_lnum,
li->loc_startchr, li->loc_endchr);
}
}
static value caml_convert_debuginfo(debuginfo dbg)
{
CAMLparam0();
- CAMLlocal2(p, fname);
+ CAMLlocal3(p, fname, dname);
struct caml_loc_info li;
caml_debuginfo_location(dbg, &li);
if (li.loc_valid) {
fname = caml_copy_string(li.loc_filename);
- p = caml_alloc_small(6, 0);
+ dname = caml_copy_string(li.loc_defname);
+ p = caml_alloc_small(7, 0);
Field(p, 0) = Val_bool(li.loc_is_raise);
Field(p, 1) = fname;
Field(p, 2) = Val_int(li.loc_lnum);
Field(p, 3) = Val_int(li.loc_startchr);
Field(p, 4) = Val_int(li.loc_endchr);
Field(p, 5) = Val_bool(li.loc_is_inlined);
+ Field(p, 6) = dname;
} else {
p = caml_alloc_small(1, 1);
Field(p, 0) = Val_bool(li.loc_is_raise);
CAMLreturn(res);
}
-CAMLprim value caml_get_current_callstack(value max_frames_value) {
+CAMLprim value caml_get_current_callstack(value max_frames_value)
+{
CAMLparam1(max_frames_value);
CAMLlocal1(res);
-
- res = caml_alloc(caml_current_callstack_size(Long_val(max_frames_value)), 0);
- caml_current_callstack_write(res);
-
+ value* callstack = NULL;
+ intnat callstack_alloc_len = 0;
+ intnat callstack_len =
+ caml_collect_current_callstack(&callstack, &callstack_alloc_len,
+ Long_val(max_frames_value), -1);
+ res = caml_alloc(callstack_len, 0);
+ memcpy(Op_val(res), callstack, sizeof(value) * callstack_len);
+ caml_stat_free(callstack);
CAMLreturn(res);
}
EV_POS = 0,
EV_MODULE = 1,
EV_LOC = 2,
- EV_KIND = 3
+ EV_KIND = 3,
+ EV_DEFNAME = 4
};
/* Location of fields in the Location.t record. */
struct ev_info {
code_t ev_pc;
char *ev_filename;
+ char *ev_defname;
int ev_lnum;
int ev_startchr;
int ev_endchr;
static int cmp_ev_info(const void *a, const void *b)
{
- code_t pc_a = ((const struct ev_info*)a)->ev_pc;
- code_t pc_b = ((const struct ev_info*)b)->ev_pc;
+ const struct ev_info* ev_a = a;
+ const struct ev_info* ev_b = b;
+ code_t pc_a = ev_a->ev_pc;
+ code_t pc_b = ev_b->ev_pc;
+ int num_a;
+ int num_b;
+
+ /* Perform a full lexicographic comparison to make sure the resulting order is
+ the same under all implementations of qsort (which is not stable). */
+
if (pc_a > pc_b) return 1;
if (pc_a < pc_b) return -1;
+
+ num_a = ev_a->ev_lnum;
+ num_b = ev_b->ev_lnum;
+
+ if (num_a > num_b) return 1;
+ if (num_a < num_b) return -1;
+
+ num_a = ev_a->ev_startchr;
+ num_b = ev_b->ev_startchr;
+
+ if (num_a > num_b) return 1;
+ if (num_a < num_b) return -1;
+
+ num_a = ev_a->ev_endchr;
+ num_b = ev_b->ev_endchr;
+
+ if (num_a > num_b) return 1;
+ if (num_a < num_b) return -1;
+
return 0;
}
ev_start = Field(Field(ev, EV_LOC), LOC_START);
{
- uintnat fnsz = caml_string_length(Field(ev_start, POS_FNAME)) + 1;
- events[j].ev_filename = (char*)caml_stat_alloc_noexc(fnsz);
+ const char *fname = String_val(Field(ev_start, POS_FNAME));
+ events[j].ev_filename = caml_stat_strdup_noexc(fname);
if(events[j].ev_filename == NULL)
caml_fatal_error ("caml_add_debug_info: out of memory");
- memcpy(events[j].ev_filename,
- String_val(Field(ev_start, POS_FNAME)),
- fnsz);
+ }
+
+ if (Is_block(Field(ev, EV_DEFNAME)) &&
+ Tag_val(Field(ev, EV_DEFNAME)) == String_tag) {
+ const char *dname = String_val(Field(ev, EV_DEFNAME));
+ events[j].ev_defname = caml_stat_strdup_noexc(dname);
+ if (events[j].ev_defname == NULL)
+ caml_fatal_error ("caml_add_debug_info: out of memory");
+ } else {
+ events[j].ev_defname = "<old bytecode>";
}
events[j].ev_lnum = Int_val(Field(ev_start, POS_LNUM));
return NULL;
}
-intnat caml_current_callstack_size(intnat max_frames)
+#define Default_callstack_size 32
+intnat caml_collect_current_callstack(value** ptrace, intnat* plen,
+ intnat max_frames, int alloc_idx)
{
- intnat trace_size;
value * sp = Caml_state->extern_sp;
value * trsp = Caml_state->trapsp;
+ intnat trace_pos = 0;
+ CAMLassert(alloc_idx == 0 || alloc_idx == -1);
+
+ if (max_frames <= 0) return 0;
+ if (*plen == 0) {
+ value* trace =
+ caml_stat_alloc_noexc(Default_callstack_size * sizeof(value));
+ if (trace == NULL) return 0;
+ *ptrace = trace;
+ *plen = Default_callstack_size;
+ }
- for (trace_size = 0; trace_size < max_frames; trace_size++) {
+ while (trace_pos < max_frames) {
code_t p = caml_next_frame_pointer(&sp, &trsp);
if (p == NULL) break;
+ if (trace_pos == *plen) {
+ intnat new_len = *plen * 2;
+ value * trace = caml_stat_resize_noexc(*ptrace, new_len * sizeof(value));
+ if (trace == NULL) break;
+ *ptrace = trace;
+ *plen = new_len;
+ }
+ (*ptrace)[trace_pos++] = Val_backtrace_slot(p);
}
- return trace_size;
-}
-
-void caml_current_callstack_write(value trace) {
- value * sp = Caml_state->extern_sp;
- value * trsp = Caml_state->trapsp;
- uintnat trace_pos, trace_size = Wosize_val(trace);
-
- for (trace_pos = 0; trace_pos < trace_size; trace_pos++) {
- code_t p = caml_next_frame_pointer(&sp, &trsp);
- CAMLassert(p != NULL);
- /* [Val_backtrace_slot(...)] is always a long, no need to call
- [caml_modify]. */
- Field(trace, trace_pos) = Val_backtrace_slot(p);
- }
+ return trace_pos;
}
/* Read the debugging info contained in the current bytecode executable. */
li->loc_valid = 1;
li->loc_is_inlined = 0;
li->loc_filename = event->ev_filename;
+ li->loc_defname = event->ev_defname;
li->loc_lnum = event->ev_lnum;
li->loc_startchr = event->ev_startchr;
li->loc_endchr = event->ev_endchr;
}
}
-intnat caml_current_callstack_size(intnat max_frames) {
- intnat trace_size = 0;
+/* A backtrace_slot is either a debuginfo or a frame_descr* */
+#define Slot_is_debuginfo(s) ((uintnat)(s) & 2)
+#define Debuginfo_slot(s) ((debuginfo)((uintnat)(s) - 2))
+#define Slot_debuginfo(d) ((backtrace_slot)((uintnat)(d) + 2))
+#define Frame_descr_slot(s) ((frame_descr*)(s))
+#define Slot_frame_descr(f) ((backtrace_slot)(f))
+static debuginfo debuginfo_extract(frame_descr* d, int alloc_idx);
+
+#define Default_callstack_size 32
+intnat caml_collect_current_callstack(value** ptrace, intnat* plen,
+ intnat max_frames, int alloc_idx)
+{
uintnat pc = Caml_state->last_return_address;
char * sp = Caml_state->bottom_of_stack;
+ intnat trace_pos = 0;
- while (1) {
- frame_descr * descr = caml_next_frame_descriptor(&pc, &sp);
- if (descr == NULL) break;
- if (trace_size >= max_frames) break;
- ++trace_size;
-
- if (sp > Caml_state->top_of_stack) break;
+ if (max_frames <= 0) return 0;
+ if (*plen == 0) {
+ value* trace =
+ caml_stat_alloc_noexc(Default_callstack_size * sizeof(value));
+ if (trace == NULL) return 0;
+ *ptrace = trace;
+ *plen = Default_callstack_size;
}
- return trace_size;
-}
-
-void caml_current_callstack_write(value trace) {
- uintnat pc = Caml_state->last_return_address;
- char * sp = Caml_state->bottom_of_stack;
- intnat trace_pos, trace_size = Wosize_val(trace);
+ if (alloc_idx >= 0) {
+ /* First frame has a Comballoc selector */
+ frame_descr * descr = caml_next_frame_descriptor(&pc, &sp);
+ debuginfo info;
+ if (descr == NULL) return 0;
+ info = debuginfo_extract(descr, alloc_idx);
+ if (info != NULL) {
+ CAMLassert(((uintnat)info & 3) == 0);
+ (*ptrace)[trace_pos++] = Val_backtrace_slot(Slot_debuginfo(info));
+ } else {
+ (*ptrace)[trace_pos++] = Val_backtrace_slot(Slot_frame_descr(descr));
+ }
+ }
- for (trace_pos = 0; trace_pos < trace_size; trace_pos++) {
+ while (trace_pos < max_frames) {
frame_descr * descr = caml_next_frame_descriptor(&pc, &sp);
- CAMLassert(descr != NULL);
- /* [Val_backtrace_slot(...)] is always a long, no need to call
- [caml_modify]. */
- Field(trace, trace_pos) = Val_backtrace_slot((backtrace_slot) descr);
+ if (descr == NULL) break;
+ CAMLassert(((uintnat)descr & 3) == 0);
+ if (trace_pos == *plen) {
+ intnat new_len = *plen * 2;
+ value * trace = caml_stat_resize_noexc(*ptrace, new_len * sizeof(value));
+ if (trace == NULL) break;
+ *ptrace = trace;
+ *plen = new_len;
+ }
+ (*ptrace)[trace_pos++] = Val_backtrace_slot(Slot_frame_descr(descr));
}
+
+ return trace_pos;
}
-debuginfo caml_debuginfo_extract(backtrace_slot slot)
+static debuginfo debuginfo_extract(frame_descr* d, int alloc_idx)
{
- uintnat infoptr;
- frame_descr * d = (frame_descr *)slot;
+ unsigned char* infoptr;
+ uint32_t debuginfo_offset;
+
+ /* The special frames marking the top of an ML stack chunk are never
+ returned by caml_next_frame_descriptor, so should never reach here. */
+ CAMLassert(d->frame_size != 0xffff);
if ((d->frame_size & 1) == 0) {
return NULL;
}
/* Recover debugging info */
- infoptr = ((uintnat) d +
- sizeof(char *) + sizeof(short) + sizeof(short) +
- sizeof(short) * d->num_live + sizeof(frame_descr *) - 1)
- & -sizeof(frame_descr *);
- return *((debuginfo*)infoptr);
+ infoptr = (unsigned char*)&d->live_ofs[d->num_live];
+ if (d->frame_size & 2) {
+ CAMLassert(alloc_idx == -1 || (0 <= alloc_idx && alloc_idx < *infoptr));
+ /* skip alloc_lengths */
+ infoptr += *infoptr + 1;
+ /* align to 32 bits */
+ infoptr = Align_to(infoptr, uint32_t);
+ /* select the right debug info for this allocation */
+ if (alloc_idx != -1) {
+ infoptr += alloc_idx * sizeof(uint32_t);
+ if (*(uint32_t*)infoptr == 0) {
+ /* No debug info for this particular allocation */
+ return NULL;
+ }
+ } else {
+ /* We don't care which alloc_idx we use, so use the first
+ that has debug info. (e.g. this is a backtrace through a
+ finaliser/signal handler triggered via a Comballoc alloc) */
+ while (*(uint32_t*)infoptr == 0) {
+ infoptr += sizeof(uint32_t);
+ }
+ }
+ } else {
+ /* align to 32 bits */
+ infoptr = Align_to(infoptr, uint32_t);
+ CAMLassert(alloc_idx == -1);
+ }
+ debuginfo_offset = *(uint32_t*)infoptr;
+ CAMLassert(debuginfo_offset != 0 && (debuginfo_offset & 3) == 0);
+ return (debuginfo)(infoptr + debuginfo_offset);
+}
+
+debuginfo caml_debuginfo_extract(backtrace_slot slot)
+{
+ if (Slot_is_debuginfo(slot)) {
+ /* already a decoded debuginfo */
+ return Debuginfo_slot(slot);
+ } else {
+ return debuginfo_extract(Frame_descr_slot(slot), -1);
+ }
}
debuginfo caml_debuginfo_next(debuginfo dbg)
return NULL;
infoptr = dbg;
- infoptr += 2; /* Two packed info fields */
- return *((debuginfo*)infoptr);
+ if ((infoptr[0] & 1) == 0)
+ /* No next debuginfo */
+ return NULL;
+ else
+ /* Next debuginfo is after the two packed info fields */
+ return (debuginfo*)(infoptr + 2);
}
+/* Multiple names may share the same filename,
+ so it is referenced as an offset instead of stored inline */
+struct name_info {
+ int32_t filename_offs;
+ char name[1];
+};
+
/* Extract location information for the given frame descriptor */
void caml_debuginfo_location(debuginfo dbg, /*out*/ struct caml_loc_info * li)
{
uint32_t info1, info2;
+ struct name_info * name_info;
/* If no debugging information available, print nothing.
When everything is compiled with -g, this corresponds to
/* Recover debugging info */
info1 = ((uint32_t *)dbg)[0];
info2 = ((uint32_t *)dbg)[1];
+ name_info = (struct name_info*)((char *) dbg + (info1 & 0x3FFFFFC));
/* Format of the two info words:
- llllllllllllllllllll aaaaaaaa bbbbbbbbbb nnnnnnnnnnnnnnnnnnnnnnnn kk
- 44 36 26 2 0
+ llllllllllllllllllll aaaaaaaa bbbbbbbbbb ffffffffffffffffffffffff k n
+ 44 36 26 2 1 0
(32+12) (32+4)
- k ( 2 bits): 0 if it's a call
+ n ( 1 bit ): 0 if this is the final debuginfo
+ 1 if there's another following this one
+ k ( 1 bit ): 0 if it's a call
1 if it's a raise
- n (24 bits): offset (in 4-byte words) of file name relative to dbg
+ f (24 bits): offset (in 4-byte words) of file name relative to dbg
l (20 bits): line number
a ( 8 bits): beginning of character range
b (10 bits): end of character range */
li->loc_valid = 1;
- li->loc_is_raise = (info1 & 3) == 1;
+ li->loc_is_raise = (info1 & 2) == 2;
li->loc_is_inlined = caml_debuginfo_next(dbg) != NULL;
- li->loc_filename = (char *) dbg + (info1 & 0x3FFFFFC);
+ li->loc_defname = name_info->name;
+ li->loc_filename =
+ (char *)name_info + name_info->filename_offs;
li->loc_lnum = info2 >> 12;
li->loc_startchr = (info2 >> 4) & 0xFF;
li->loc_endchr = ((info2 & 0xF) << 6) | (info1 >> 26);
/* Operation table for bigarrays */
CAMLexport struct custom_operations caml_ba_ops = {
- "_bigarray",
+ "_bigarr02",
caml_ba_finalize,
caml_ba_compare,
caml_ba_hash,
/* Serialize header information */
caml_serialize_int_4(b->num_dims);
caml_serialize_int_4(b->flags & (CAML_BA_KIND_MASK | CAML_BA_LAYOUT_MASK));
- /* On a 64-bit machine, if any of the dimensions is >= 2^32,
- the size of the marshaled data will be >= 2^32 and
- extern_value() will fail. So, it is safe to write the dimensions
- as 32-bit unsigned integers. */
- for (i = 0; i < b->num_dims; i++) caml_serialize_int_4(b->dim[i]);
+ for (i = 0; i < b->num_dims; i++) {
+ intnat len = b->dim[i];
+ if (len < 0xffff) {
+ caml_serialize_int_2(len);
+ } else {
+ caml_serialize_int_2(0xffff);
+ caml_serialize_int_8(len);
+ }
+ }
/* Compute total number of elements */
num_elts = 1;
for (i = 0; i < b->num_dims; i++) num_elts = num_elts * b->dim[i];
caml_deserialize_error("input_value: wrong number of bigarray dimensions");
b->flags = caml_deserialize_uint_4() | CAML_BA_MANAGED;
b->proxy = NULL;
- for (i = 0; i < b->num_dims; i++) b->dim[i] = caml_deserialize_uint_4();
+ for (i = 0; i < b->num_dims; i++) {
+ intnat len = caml_deserialize_uint_2();
+ if (len == 0xffff) len = caml_deserialize_uint_8();
+ b->dim[i] = len;
+ }
/* Compute total number of elements. Watch out for overflows (MPR#7765). */
num_elts = 1;
for (i = 0; i < b->num_dims; i++) {
CAMLextern int caml_convert_flag_list (value, int *);
/* Convenience functions to deal with unboxable types. */
-static inline value caml_alloc_unboxed (value arg) { return arg; }
-static inline value caml_alloc_boxed (value arg) {
+Caml_inline value caml_alloc_unboxed (value arg) { return arg; }
+Caml_inline value caml_alloc_boxed (value arg) {
value result = caml_alloc_small (1, 0);
Field (result, 0) = arg;
return result;
}
-static inline value caml_field_unboxed (value arg) { return arg; }
-static inline value caml_field_boxed (value arg) { return Field (arg, 0); }
+Caml_inline value caml_field_unboxed (value arg) { return arg; }
+Caml_inline value caml_field_boxed (value arg) { return Field (arg, 0); }
/* Unannotated unboxable types are boxed by default. (may change in the
future) */
int loc_valid;
int loc_is_raise;
char * loc_filename;
+ char * loc_defname;
int loc_lnum;
int loc_startchr;
int loc_endchr;
};
/* When compiling with -g, backtrace slots have debug info associated.
- * When a call is inlined in native mode, debuginfos form a linked list.
+ * When a call is inlined in native mode, debuginfos form a sequence.
*/
typedef void * debuginfo;
* It defines the [caml_stash_backtrace] function, which is called to quickly
* fill the backtrace buffer by walking the stack when an exception is raised.
*
- * It also defines the two following functions, which makes it possible
- * to store upto [max_frames_value] frames of the current call
- * stack. This is not used in an exception-raising context, but only
- * when the user requests to save the trace (hopefully less often), or
- * the context of profiling. Instead of using a bounded buffer as
- * [caml_stash_backtrace], we first traverse the stack to compute the
- * right size, then allocate space for the trace.
+ * It also defines [caml_collect_current_callstack], which stores up
+ * to [max_frames] frames of the current call stack into the
+ * statically allocated buffer [*pbuffer] of length [*plen]. If the
+ * buffer is not long enough, it will be reallocated. The number of
+ * frames collected is returned.
*
- * The first function, [caml_current_callstack_size] computes the size
- * (in words) of the needed buffer, while the second actually writes
- * the call stack to the buffer as an object of type
- * [raw_backtrace]. It should always be called with a buffer of the
- * size predicted by [caml_current_callstack_size]. The reason we use
- * two separated functions is to allow using either [caml_alloc] (for
- * performance) or [caml_alloc_shr] (when we need to avoid a call to
- * the GC, in memprof.c).
+ * The alloc_idx parameter is used to select between the backtraces of
+ * different allocation sites which were combined by Comballoc.
+ * Passing -1 here means the caller doesn't care which is chosen.
*
* We use `intnat` for max_frames because, were it only `int`, passing
* `max_int` from the OCaml side would overflow on 64bits machines. */
-intnat caml_current_callstack_size(intnat max_frames);
-void caml_current_callstack_write(value trace);
+intnat caml_collect_current_callstack(value** pbuffer, intnat* plen,
+ intnat max_frames, int alloc_idx);
#endif /* CAML_INTERNALS */
#endif
#if defined(_MSC_VER) && !defined(__cplusplus)
-#define inline __inline
+#define Caml_inline static __inline
+#else
+#define Caml_inline static inline
#endif
#include "s.h"
#else
#error "No 16-bit integer type available"
#endif
+typedef unsigned char uint8_t;
#endif
#if SIZEOF_PTR == SIZEOF_LONG
#define CAML_STATE_H
#include <stddef.h>
+#include <stdio.h>
#include "misc.h"
#include "mlvalues.h"
#endif
#include "domain_state.tbl"
#undef DOMAIN_STATE
+ CAMLalign(8) char end_of_domain_state;
} caml_domain_state;
enum {
/* Check that the structure was laid out without padding,
since the runtime assumes this in computing offsets */
CAML_STATIC_ASSERT(
- sizeof(caml_domain_state) ==
- (Domain_state_num_fields
- ) * 8);
+ offsetof(caml_domain_state, end_of_domain_state) ==
+ Domain_state_num_fields * 8);
CAMLextern caml_domain_state* Caml_state;
#ifdef CAML_NAME_SPACE
DOMAIN_STATE(intnat, stat_compactions)
DOMAIN_STATE(intnat, stat_heap_chunks)
/* See gc_ctrl.c */
+
+DOMAIN_STATE(uintnat, eventlog_startup_timestamp)
+DOMAIN_STATE(uint32_t, eventlog_startup_pid)
+DOMAIN_STATE(uintnat, eventlog_paused)
+DOMAIN_STATE(uintnat, eventlog_enabled)
+DOMAIN_STATE(FILE*, eventlog_out)
+/* See eventlog.c */
--- /dev/null
+/**************************************************************************/
+/* */
+/* OCaml */
+/* */
+/* Stephen Dolan, University of Cambridge */
+/* Enguerrand Decorne, Tarides */
+/* */
+/* Copyright 2020 University of Cambridge */
+/* Copyright 2020 Tarides */
+/* */
+/* All rights reserved. This file is distributed under the terms of */
+/* the GNU Lesser General Public License version 2.1, with the */
+/* special exception on linking described in the file LICENSE. */
+/* */
+/**************************************************************************/
+
+#ifndef CAML_EVENTLOG_H
+#define CAML_EVENTLOG_H
+
+typedef enum {
+ EV_ENTRY,
+ EV_EXIT,
+ EV_COUNTER,
+ EV_ALLOC,
+ EV_FLUSH
+} ev_type;
+
+typedef enum {
+ EV_COMPACT_MAIN,
+ EV_COMPACT_RECOMPACT,
+ EV_EXPLICIT_GC_SET,
+ EV_EXPLICIT_GC_STAT,
+ EV_EXPLICIT_GC_MINOR,
+ EV_EXPLICIT_GC_MAJOR,
+ EV_EXPLICIT_GC_FULL_MAJOR,
+ EV_EXPLICIT_GC_COMPACT,
+ EV_MAJOR,
+ EV_MAJOR_ROOTS,
+ EV_MAJOR_SWEEP,
+ EV_MAJOR_MARK_ROOTS,
+ EV_MAJOR_MARK_MAIN,
+ EV_MAJOR_MARK_FINAL,
+ EV_MAJOR_MARK,
+ EV_MAJOR_MARK_GLOBAL_ROOTS_SLICE,
+ EV_MAJOR_ROOTS_GLOBAL,
+ EV_MAJOR_ROOTS_DYNAMIC_GLOBAL,
+ EV_MAJOR_ROOTS_LOCAL,
+ EV_MAJOR_ROOTS_C,
+ EV_MAJOR_ROOTS_FINALISED,
+ EV_MAJOR_ROOTS_MEMPROF,
+ EV_MAJOR_ROOTS_HOOK,
+ EV_MAJOR_CHECK_AND_COMPACT,
+ EV_MINOR,
+ EV_MINOR_LOCAL_ROOTS,
+ EV_MINOR_REF_TABLES,
+ EV_MINOR_COPY,
+ EV_MINOR_UPDATE_WEAK,
+ EV_MINOR_FINALIZED,
+ EV_EXPLICIT_GC_MAJOR_SLICE
+} ev_gc_phase;
+
+typedef enum {
+ EV_C_ALLOC_JUMP,
+ EV_C_FORCE_MINOR_ALLOC_SMALL,
+ EV_C_FORCE_MINOR_MAKE_VECT,
+ EV_C_FORCE_MINOR_SET_MINOR_HEAP_SIZE,
+ EV_C_FORCE_MINOR_WEAK,
+ EV_C_FORCE_MINOR_MEMPROF,
+ EV_C_MAJOR_MARK_SLICE_REMAIN,
+ EV_C_MAJOR_MARK_SLICE_FIELDS,
+ EV_C_MAJOR_MARK_SLICE_POINTERS,
+ EV_C_MAJOR_WORK_EXTRA,
+ EV_C_MAJOR_WORK_MARK,
+ EV_C_MAJOR_WORK_SWEEP,
+ EV_C_MINOR_PROMOTED,
+ EV_C_REQUEST_MAJOR_ALLOC_SHR,
+ EV_C_REQUEST_MAJOR_ADJUST_GC_SPEED,
+ EV_C_REQUEST_MINOR_REALLOC_REF_TABLE,
+ EV_C_REQUEST_MINOR_REALLOC_EPHE_REF_TABLE,
+ EV_C_REQUEST_MINOR_REALLOC_CUSTOM_TABLE
+} ev_gc_counter;
+
+#ifdef CAML_INSTR
+
+#define CAML_EVENTLOG_DO(f) if (Caml_state->eventlog_enabled &&\
+ !Caml_state->eventlog_paused) f
+
+#define CAML_EVENTLOG_INIT() caml_eventlog_init()
+#define CAML_EVENTLOG_DISABLE() caml_eventlog_disable()
+#define CAML_EV_BEGIN(p) caml_ev_begin(p)
+#define CAML_EV_END(p) caml_ev_end(p)
+#define CAML_EV_COUNTER(c, v) caml_ev_counter(c, v)
+#define CAML_EV_ALLOC(s) caml_ev_alloc(s)
+#define CAML_EV_ALLOC_FLUSH() caml_ev_alloc_flush()
+#define CAML_EV_FLUSH() caml_ev_flush()
+
+/* General note about the public API for the eventlog framework
+ The caml_ev_* functions are no-op when called with the eventlog framework
+ paused or disabled.
+ caml_eventlog_* functions on the other hand may introduce side effects
+ (such as write buffer flushes, or side effects in the eventlog internals.)
+
+ All these functions should be called while holding the runtime lock.
+*/
+
+void caml_eventlog_init(void);
+void caml_eventlog_disable(void);
+void caml_ev_begin(ev_gc_phase phase);
+void caml_ev_end(ev_gc_phase phase);
+void caml_ev_counter(ev_gc_counter counter, uint64_t val);
+void caml_ev_alloc(uint64_t size);
+void caml_ev_alloc_flush(void);
+void caml_ev_flush(void);
+
+#else
+
+#define CAML_EVENTLOG_DO(f) /**/
+
+#define CAML_EVENTLOG_INIT() /**/
+#define CAML_EVENTLOG_DISABLE() /**/
+#define CAML_EV_BEGIN(p) /**/
+#define CAML_EV_END(p) /**/
+#define CAML_EV_COUNTER(c, v) /**/
+#define CAML_EV_ALLOC(S) /**/
+#define CAML_EV_ALLOC_FLUSH() /**/
+#define CAML_EV_FLUSH() /**/
+
+#endif /*CAML_INSTR*/
+
+#endif /*CAML_EVENTLOG_H*/
/* Magic number for this release */
-#define EXEC_MAGIC "Caml1999X027"
+#define EXEC_MAGIC "Caml1999X028"
#endif /* CAML_INTERNALS */
extern void (*caml_fl_p_check) (void);
#endif
-static inline header_t *caml_fl_allocate (mlsize_t wo_sz)
+Caml_inline header_t *caml_fl_allocate (mlsize_t wo_sz)
{ return (*caml_fl_p_allocate) (wo_sz); }
-static inline void caml_fl_init_merge (void)
+Caml_inline void caml_fl_init_merge (void)
{ (*caml_fl_p_init_merge) (); }
-static inline header_t *caml_fl_merge_block (value bp, char *limit)
+Caml_inline header_t *caml_fl_merge_block (value bp, char *limit)
{ return (*caml_fl_p_merge_block) (bp, limit); }
-static inline void caml_fl_add_blocks (value bp)
+Caml_inline void caml_fl_add_blocks (value bp)
{ (*caml_fl_p_add_blocks) (bp); }
-static inline void caml_make_free_blocks
+Caml_inline void caml_make_free_blocks
(value *p, mlsize_t size, int do_merge, int color)
{ (*caml_fl_p_make_free_blocks) (p, size, do_merge, color); }
extern void caml_fl_reset_and_switch_policy (intnat);
#ifdef DEBUG
-static inline void caml_fl_check (void)
+Caml_inline void caml_fl_check (void)
{ (*caml_fl_p_check) (); }
#endif
#undef WITH_SPACETIME
#undef ENABLE_CALL_COUNTS
-#undef NONSTANDARD_DIV_MOD
-
-/* Leave NONSTANDARD_DIV_MOD undefined if the C operators / and % implement
- round-towards-zero semantics, as specified by ISO C 9x and implemented
- by most contemporary processors. Otherwise, or if you don't know,
- define NONSTANDARD_DIV_MOD: this will select a slower but correct
- software emulation of division and modulus. */
-
#undef ASM_CFI_SUPPORTED
#undef WITH_FRAME_POINTERS
CAML_FROM_C = 0, CAML_FROM_CAML = 2
};
-extern void caml_alloc_small_dispatch (tag_t tag, intnat wosize, int flags);
+extern void caml_alloc_small_dispatch (intnat wosize, int flags,
+ int nallocs, unsigned char* alloc_lens);
// Do not call asynchronous callbacks from allocation functions
#define Alloc_small_origin CAML_FROM_C
#define Alloc_small_aux(result, wosize, tag, profinfo, track) do { \
Caml_state_field(young_ptr) -= Whsize_wosize (wosize); \
if (Caml_state_field(young_ptr) < Caml_state_field(young_limit)) { \
Setup_for_gc; \
- caml_alloc_small_dispatch((tag), (wosize), \
- (track) | Alloc_small_origin); \
+ caml_alloc_small_dispatch((wosize), (track) | Alloc_small_origin, \
+ 1, NULL); \
Restore_after_gc; \
} \
Hd_hp (Caml_state_field(young_ptr)) = \
- Make_header_with_profinfo ((wosize), (tag), Caml_black, profinfo); \
+ Make_header_with_profinfo ((wosize), (tag), 0, profinfo); \
(result) = Val_hp (Caml_state_field(young_ptr)); \
DEBUG_clear ((result), (wosize)); \
}while(0)
extern int caml_memprof_suspended;
-extern value caml_memprof_handle_postponed_exn();
+extern value caml_memprof_handle_postponed_exn(void);
extern void caml_memprof_track_alloc_shr(value block);
-extern void caml_memprof_track_young(tag_t tag, uintnat wosize, int from_caml);
+extern void caml_memprof_track_young(uintnat wosize, int from_caml,
+ int nallocs, unsigned char* alloc_lens);
extern void caml_memprof_track_interned(header_t* block, header_t* blockend);
extern void caml_memprof_renew_minor_sample(void);
extern value* caml_memprof_young_trigger;
-extern void caml_memprof_scan_roots(scanning_action f);
+extern void caml_memprof_oldify_young_roots(void);
+extern void caml_memprof_minor_update(void);
+extern void caml_memprof_do_roots(scanning_action f);
+extern void caml_memprof_update_clean_phase(void);
+extern void caml_memprof_invert_tracked(void);
+
+extern void caml_memprof_shutdown(void);
+
+struct caml_memprof_th_ctx {
+ int suspended, callback_running;
+};
+extern void caml_memprof_init_th_ctx(struct caml_memprof_th_ctx* ctx);
+extern void caml_memprof_stop_th_ctx(struct caml_memprof_th_ctx* ctx);
+extern void caml_memprof_save_th_ctx(struct caml_memprof_th_ctx* ctx);
+extern void caml_memprof_restore_th_ctx(const struct caml_memprof_th_ctx* ctx);
#endif
asize_t, asize_t);
void caml_alloc_minor_tables (void);
+/* Asserts that a word is a valid header for a young object */
+#define CAMLassert_young_header(hd) \
+ CAMLassert(Wosize_hd(hd) > 0 && \
+ Wosize_hd(hd) <= Max_young_wosize && \
+ Color_hd(hd) == 0)
+
#define Oldify(p) do{ \
value __oldify__v__ = *p; \
if (Is_block (__oldify__v__) && Is_young (__oldify__v__)){ \
} \
}while(0)
-static inline void add_to_ref_table (struct caml_ref_table *tbl, value *p)
+Caml_inline void add_to_ref_table (struct caml_ref_table *tbl, value *p)
{
if (tbl->ptr >= tbl->limit){
CAMLassert (tbl->ptr == tbl->limit);
*tbl->ptr++ = p;
}
-static inline void add_to_ephe_ref_table (struct caml_ephe_ref_table *tbl,
+Caml_inline void add_to_ephe_ref_table (struct caml_ephe_ref_table *tbl,
value ar, mlsize_t offset)
{
struct caml_ephe_ref_elt *ephe_ref;
CAMLassert(ephe_ref->offset < Wosize_val(ephe_ref->ephe));
}
-static inline void add_to_custom_table (struct caml_custom_table *tbl, value v,
+Caml_inline void add_to_custom_table (struct caml_custom_table *tbl, value v,
mlsize_t mem, mlsize_t max)
{
struct caml_custom_elt *elt;
#include <stddef.h>
#include <stdlib.h>
-#include <stdio.h>
#include <stdarg.h>
/* Basic types and constants */
typedef size_t asize_t;
-#ifndef NULL
-#define NULL 0
-#endif
-
#if defined(__GNUC__) || defined(__clang__)
/* Supported since at least GCC 3.1 */
#define CAMLdeprecated_typedef(name, type) \
/* we need to be able to compute the exact offset of each member. */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
#define CAMLalign(n) _Alignas(n)
-#elif defined(__cplusplus) && _MSC_VER >= 1900
+#elif defined(__cplusplus) && (__cplusplus >= 201103L || _MSC_VER >= 1900)
#define CAMLalign(n) alignas(n)
#elif defined(SUPPORTS_ALIGNED_ATTRIBUTE)
#define CAMLalign(n) __attribute__((aligned(n)))
If overflow is reported, this is the exact result modulo 2 to the word size.
*/
-static inline int caml_uadd_overflow(uintnat a, uintnat b, uintnat * res)
+Caml_inline int caml_uadd_overflow(uintnat a, uintnat b, uintnat * res)
{
#if __GNUC__ >= 5 || Caml_has_builtin(__builtin_add_overflow)
return __builtin_add_overflow(a, b, res);
#endif
}
-static inline int caml_usub_overflow(uintnat a, uintnat b, uintnat * res)
+Caml_inline int caml_usub_overflow(uintnat a, uintnat b, uintnat * res)
{
#if __GNUC__ >= 5 || Caml_has_builtin(__builtin_sub_overflow)
return __builtin_sub_overflow(a, b, res);
}
#if __GNUC__ >= 5 || Caml_has_builtin(__builtin_mul_overflow)
-static inline int caml_umul_overflow(uintnat a, uintnat b, uintnat * res)
+Caml_inline int caml_umul_overflow(uintnat a, uintnat b, uintnat * res)
{
return __builtin_mul_overflow(a, b, res);
}
/* snprintf emulation for Win32 */
-#if defined(_WIN32) && !defined(_UCRT)
+#ifdef _WIN32
+#ifndef _UCRT
extern int caml_snprintf(char * buf, size_t size, const char * format, ...);
#define snprintf caml_snprintf
#endif
-#ifdef CAML_INSTR
-/* Timers and counters for GC latency profiling (Linux-only) */
-
-#include <time.h>
-#include <stdio.h>
-
-extern intnat caml_instr_starttime, caml_instr_stoptime;
-
-struct caml_instr_block {
- struct timespec ts[10];
- char *tag[10];
- int index;
- struct caml_instr_block *next;
-};
-
-extern struct caml_instr_block *caml_instr_log;
-
-/* Declare a timer/counter name. [t] must be a new variable name. */
-#define CAML_INSTR_DECLARE(t) \
- struct caml_instr_block *t = NULL
-
-/* Allocate the data block for a given name.
- [t] must have been declared with [CAML_INSTR_DECLARE]. */
-#define CAML_INSTR_ALLOC(t) do{ \
- if (Caml_state_field(stat_minor_collections) >= caml_instr_starttime \
- && Caml_state_field(stat_minor_collections) < caml_instr_stoptime){ \
- t = caml_stat_alloc_noexc (sizeof (struct caml_instr_block)); \
- t->index = 0; \
- t->tag[0] = ""; \
- t->next = caml_instr_log; \
- caml_instr_log = t; \
- } \
- }while(0)
-
-/* Allocate the data block and start the timer.
- [t] must have been declared with [CAML_INSTR_DECLARE]
- and allocated with [CAML_INSTR_ALLOC]. */
-#define CAML_INSTR_START(t, msg) do{ \
- if (t != NULL){ \
- t->tag[0] = msg; \
- clock_gettime (CLOCK_REALTIME, &(t->ts[0])); \
- } \
- }while(0)
-
-/* Declare a timer, allocate its data, and start it.
- [t] must be a new variable name. */
-#define CAML_INSTR_SETUP(t, msg) \
- CAML_INSTR_DECLARE (t); \
- CAML_INSTR_ALLOC (t); \
- CAML_INSTR_START (t, msg)
-
-/* Record an intermediate time within a given timer.
- [t] must have been declared, allocated, and started. */
-#define CAML_INSTR_TIME(t, msg) do{ \
- if (t != NULL){ \
- ++ t->index; \
- t->tag[t->index] = (msg); \
- clock_gettime (CLOCK_REALTIME, &(t->ts[t->index])); \
- } \
- }while(0)
-
-/* Record an integer data point.
- If [msg] ends with # it will be interpreted as an integer-valued event.
- If it ends with @ it will be interpreted as an event counter.
-*/
-#define CAML_INSTR_INT(msg, data) do{ \
- CAML_INSTR_SETUP (__caml_tmp, ""); \
- if (__caml_tmp != NULL){ \
- __caml_tmp->index = 1; \
- __caml_tmp->tag[1] = msg; \
- __caml_tmp->ts[1].tv_sec = 0; \
- __caml_tmp->ts[1].tv_nsec = (data); \
- } \
- }while(0)
-
-/* This function is called at the start of the program to set up
- the data for the above macros.
-*/
-extern void caml_instr_init (void);
-
-/* This function is automatically called by the runtime to output
- the collected data to the dump file. */
-extern void caml_instr_atexit (void);
-
-#else /* CAML_INSTR */
-
-#define CAML_INSTR_DECLARE(t) /**/
-#define CAML_INSTR_ALLOC(t) /**/
-#define CAML_INSTR_START(t, name) /**/
-#define CAML_INSTR_SETUP(t, name) /**/
-#define CAML_INSTR_TIME(t, msg) /**/
-#define CAML_INSTR_INT(msg, c) /**/
-#define caml_instr_init() /**/
-#define caml_instr_atexit() /**/
-
-#endif /* CAML_INSTR */
+extern int caml_snwprintf(wchar_t * buf,
+ size_t size,
+ const wchar_t * format, ...);
+#define snprintf_os caml_snwprintf
+#else
+#define snprintf_os snprintf
+#endif
/* Macro used to deactivate thread and address sanitizers on some
functions. */
/* The [backtrace_slot] type represents values stored in
* [Caml_state->backtrace_buffer]. In bytecode, it is the same as a
- * [code_t], in native code it as a [frame_descr *]. The difference
- * doesn't matter for code outside [backtrace_{byt,nat}.c],
+ * [code_t], in native code it is either a [frame_descr *] or a [debuginfo],
+ * depending on the second-lowest bit. In any case, the lowest bit must
+ * be 0.
+ * The representation doesn't matter for code outside [backtrace_{byt,nat}.c],
* so it is just exposed as a [void *].
*/
typedef void * backtrace_slot;
#define Double_field(v,i) Double_flat_field(v,i)
#define Store_double_field(v,i,d) Store_double_flat_field(v,i,d)
#else
- static inline double Double_field (value v, mlsize_t i) {
+ Caml_inline double Double_field (value v, mlsize_t i) {
if (Tag_val (v) == Double_array_tag){
return Double_flat_field (v, i);
}else{
return Double_array_field (v, i);
}
}
- static inline void Store_double_field (value v, mlsize_t i, double d) {
+ Caml_inline void Store_double_field (value v, mlsize_t i, double d) {
if (Tag_val (v) == Double_array_tag){
Store_double_flat_field (v, i, d);
}else{
/* Define HAS_PUTENV if you have putenv(). */
+#undef HAS_SETENV_UNSETENV
+
+/* Define HAS_SETENV_UNSETENV if you have setenv() and unsetenv(). */
+
#undef HAS_LOCALE_H
/* Define HAS_LOCALE_H if you have the include file <locale.h> and the
#undef HAS_BROKEN_PRINTF
#undef HAS_STRERROR
+
+#undef HAS_POSIX_MONOTONIC_CLOCK
+
+#undef HAS_MACH_ABSOLUTE_TIME
#define Callback_link(sp) ((struct caml_context *)((sp) + 16))
#endif
+#ifdef TARGET_riscv
+#define Saved_return_address(sp) *((intnat *)((sp) - 8))
+#define Callback_link(sp) ((struct caml_context *)((sp) + 16))
+#endif
+
/* Structure of OCaml callback contexts */
struct caml_context {
uintnat retaddr;
unsigned short frame_size;
unsigned short num_live;
- unsigned short live_ofs[1];
+ unsigned short live_ofs[1 /* num_live */];
+ /*
+ If frame_size & 2, then allocation info follows:
+ unsigned char num_allocs;
+ unsigned char alloc_lengths[num_alloc];
+
+ If frame_size & 1, then debug info follows:
+ uint32_t debug_info_offset[num_debug];
+
+ Debug info is stored as relative offsets to debuginfo structures.
+ num_debug is num_alloc if frame_size & 2, otherwise 1. */
} frame_descr;
+/* Allocation lengths are encoded as 0-255, giving sizes 1-256 */
+#define Wosize_encoded_alloc_len(n) ((uintnat)(n) + 1)
+
+/* Used to compute offsets in frame tables.
+ ty must have power-of-2 size */
+#define Align_to(p, ty) \
+ (void*)(((uintnat)(p) + sizeof(ty) - 1) & -sizeof(ty))
+
+
/* Hash table of frame descriptors */
extern frame_descr ** caml_frame_descriptors;
/* In the header, in order to let major_gc.c
and weak.c see the body of the function */
-static inline void caml_ephe_clean (value v){
+Caml_inline void caml_ephe_clean_partial (value v,
+ mlsize_t offset_start,
+ mlsize_t offset_end) {
value child;
int release_data = 0;
- mlsize_t size, i;
- header_t hd;
+ mlsize_t i;
CAMLassert(caml_gc_phase == Phase_clean);
+ CAMLassert(2 <= offset_start
+ && offset_start <= offset_end
+ && offset_end <= Wosize_hd (Hd_val(v)));
- hd = Hd_val (v);
- size = Wosize_hd (hd);
- for (i = 2; i < size; i++){
+ for (i = offset_start; i < offset_end; i++){
child = Field (v, i);
ephemeron_again:
if (child != caml_ephe_none
child = Field (v, 1);
if(child != caml_ephe_none){
- if (release_data){
+ if (release_data){
Field (v, 1) = caml_ephe_none;
} else {
- /* The mark phase must have marked it */
- CAMLassert( !(Is_block (child) && Is_in_heap (child)
- && Is_white_val (child)) );
+ /* If we scanned all the keys and the data field remains filled,
+ then the mark phase must have marked it */
+ CAMLassert( !(offset_start == 2 && offset_end == Wosize_hd (Hd_val(v))
+ && Is_block (child) && Is_in_heap (child)
+ && Is_white_val (child)));
}
}
}
+Caml_inline void caml_ephe_clean (value v) {
+ mlsize_t size;
+ header_t hd;
+ hd = Hd_val (v);
+ size = Wosize_hd (hd);
+
+ caml_ephe_clean_partial(v, 2, size);
+}
+
+
#endif /* CAML_INTERNALS */
#ifdef __cplusplus
#include "caml/roots.h"
#include "caml/weak.h"
#include "caml/compact.h"
+#include "caml/memprof.h"
+#include "caml/eventlog.h"
extern uintnat caml_percent_free; /* major_gc.c */
extern void caml_shrink_heap (char *); /* memory.c */
caml_do_roots (caml_invert_root, 1);
/* The values to be finalised are not roots but should still be inverted */
caml_final_invert_finalisable_values ();
+ /* Idem for memprof tracked blocks */
+ caml_memprof_invert_tracked ();
ch = caml_heap_start;
while (ch != NULL){
void caml_compact_heap (intnat new_allocation_policy)
{
uintnat target_wsz, live;
- CAML_INSTR_SETUP(tmr, "compact");
CAMLassert (Caml_state->young_ptr == Caml_state->young_alloc_end);
CAMLassert (Caml_state->ref_table->ptr ==
CAMLassert (Caml_state->custom_table->ptr ==
Caml_state->custom_table->base);
+ CAML_EV_BEGIN(EV_COMPACT_MAIN);
do_compaction (new_allocation_policy);
- CAML_INSTR_TIME (tmr, "compact/main");
+ CAML_EV_END(EV_COMPACT_MAIN);
/* Compaction may fail to shrink the heap to a reasonable size
because it deals in complete chunks: if a very large chunk
is at the beginning of the heap, everything gets moved to
if (Caml_state->stat_heap_wsz > Caml_state->stat_top_heap_wsz){
Caml_state->stat_top_heap_wsz = Caml_state->stat_heap_wsz;
}
+ CAML_EV_BEGIN(EV_COMPACT_RECOMPACT);
do_compaction (-1);
CAMLassert (Caml_state->stat_heap_chunks == 1);
CAMLassert (Chunk_next (caml_heap_start) == NULL);
CAMLassert (Caml_state->stat_heap_wsz == Wsize_bsize (Chunk_size (chunk)));
- CAML_INSTR_TIME (tmr, "compact/recompact");
+ CAML_EV_END(EV_COMPACT_RECOMPACT);
}
}
#include <unistd.h>
#endif
#include <errno.h>
+#include <stdlib.h>
#include <sys/types.h>
#ifndef _WIN32
#include <sys/wait.h>
if (dbg_addr != NULL) caml_stat_free(dbg_addr);
dbg_addr = address;
+ /* #8676: erase the CAML_DEBUG_SOCKET variable so that processes
+ created by the program being debugged do not try to connect with
+ the debugger. */
+#if defined(_WIN32)
+ _wputenv(L"CAML_DEBUG_SOCKET=");
+#elif defined(HAS_SETENV_UNSETENV)
+ unsetenv("CAML_DEBUG_SOCKET");
+#endif
+
caml_ext_table_init(&breakpoints_table, 16);
#ifdef _WIN32
Caml_state->local_roots = NULL;
Caml_state->requested_major_slice = 0;
Caml_state->requested_minor_gc = 0;
+
+ Caml_state->eventlog_enabled = 0;
+ Caml_state->eventlog_paused = 0;
+ Caml_state->eventlog_startup_pid = 0;
+ Caml_state->eventlog_startup_timestamp = 0;
+ Caml_state->eventlog_out = NULL;
}
--- /dev/null
+/**************************************************************************/
+/* */
+/* OCaml */
+/* */
+/* Stephen Dolan, University of Cambridge */
+/* Enguerrand Decorne, Tarides */
+/* */
+/* Copyright 2020 University of Cambridge */
+/* Copyright 2020 Tarides */
+/* */
+/* All rights reserved. This file is distributed under the terms of */
+/* the GNU Lesser General Public License version 2.1, with the */
+/* special exception on linking described in the file LICENSE. */
+/* */
+/**************************************************************************/
+
+#define CAML_INTERNALS
+#include <stdio.h>
+#include <string.h>
+#include "caml/alloc.h"
+#include "caml/eventlog.h"
+#include "caml/misc.h"
+#include "caml/memory.h"
+#include "caml/osdeps.h"
+
+
+#ifdef _WIN32
+#include <wtypes.h>
+#include <process.h>
+#elif defined(HAS_UNISTD)
+#include <unistd.h>
+#endif
+
+#ifdef HAS_MACH_ABSOLUTE_TIME
+#include <mach/mach_time.h>
+#elif HAS_POSIX_MONOTONIC_CLOCK
+#include <time.h>
+#endif
+
+#ifdef CAML_INSTR
+
+#define CTF_MAGIC 0xc1fc1fc1
+#define CAML_TRACE_VERSION 0x1
+
+struct ctf_stream_header {
+ uint32_t magic;
+ uint16_t caml_trace_version;
+ uint16_t stream_id;
+};
+
+static struct ctf_stream_header header = {
+ CTF_MAGIC,
+ CAML_TRACE_VERSION,
+ 0
+};
+
+#pragma pack(1)
+struct ctf_event_header {
+ uint64_t timestamp;
+ uint32_t pid;
+ uint32_t id;
+};
+
+struct event {
+ struct ctf_event_header header;
+ uint16_t phase; /* for GC events */
+ uint16_t counter_kind; /* misc counter name */
+ uint8_t alloc_bucket; /* for alloc counters */
+ uint64_t count; /* for misc counters */
+};
+
+#define EVENT_BUF_SIZE 4096
+struct event_buffer {
+ uintnat ev_generated;
+ struct event events[EVENT_BUF_SIZE];
+};
+
+static struct event_buffer* evbuf;
+
+static int64_t time_counter(void)
+{
+#ifdef _WIN32
+ static double clock_freq = 0;
+ static LARGE_INTEGER now;
+
+ if (clock_freq == 0) {
+ LARGE_INTEGER f;
+ if (!QueryPerformanceFrequency(&f))
+ return 0;
+ clock_freq = (1000000000.0 / f.QuadPart);
+ };
+
+ if (!QueryPerformanceCounter(&now))
+ return 0;
+ return (int64_t)(now.QuadPart * clock_freq);
+
+#elif defined(HAS_MACH_ABSOLUTE_TIME)
+ static mach_timebase_info_data_t time_base = {0};
+
+ if (time_base.denom == 0) {
+ if (mach_timebase_info (&time_base) != KERN_SUCCESS)
+ return 0;
+
+ if (time_base.denom == 0)
+ return 0;
+ }
+
+ uint64_t now = mach_absolute_time ();
+ return (int64_t)((now * time_base.numer) / time_base.denom);
+
+#elif defined(HAS_POSIX_MONOTONIC_CLOCK)
+ struct timespec t;
+ clock_gettime(CLOCK_MONOTONIC, &t);
+ return
+ (int64_t)t.tv_sec * (int64_t)1000000000 +
+ (int64_t)t.tv_nsec;
+
+
+#endif
+}
+
+static void setup_evbuf()
+{
+ CAMLassert(!evbuf);
+ evbuf = caml_stat_alloc_noexc(sizeof(*evbuf));
+
+ if (evbuf == NULL)
+ caml_fatal_error("eventlog: could not allocate event buffer");
+
+ evbuf->ev_generated = 0;
+}
+
+#define OUTPUT_FILE_LEN 4096
+static void setup_eventlog_file()
+{
+ char_os output_file[OUTPUT_FILE_LEN];
+ char_os *eventlog_filename = NULL;
+
+ eventlog_filename = caml_secure_getenv(T("OCAML_EVENTLOG_PREFIX"));
+
+ if (eventlog_filename) {
+ int ret = snprintf_os(output_file, OUTPUT_FILE_LEN, T("%s.%d.eventlog"),
+ eventlog_filename, Caml_state->eventlog_startup_pid);
+ if (ret > OUTPUT_FILE_LEN)
+ caml_fatal_error("eventlog: specified OCAML_EVENTLOG_PREFIX is too long");
+ } else {
+ snprintf_os(output_file, OUTPUT_FILE_LEN, T("caml-%d.eventlog"),
+ Caml_state->eventlog_startup_pid);
+ }
+
+ Caml_state->eventlog_out = fopen_os(output_file, T("wb"));
+
+ if (Caml_state->eventlog_out) {
+ int ret = fwrite(&header, sizeof(struct ctf_stream_header),
+ 1, Caml_state->eventlog_out);
+ if (ret != 1)
+ caml_eventlog_disable();
+ fflush(Caml_state->eventlog_out);
+ } else {
+ caml_fatal_error("eventlog: could not open trace for writing");
+ }
+}
+#undef OUTPUT_FILE_LEN
+
+#define FWRITE_EV(item, size) \
+ if (fwrite(item, size, 1, out) != 1) \
+ goto fwrite_failure;
+
+static void flush_events(FILE* out, struct event_buffer* eb)
+{
+ uintnat i;
+ uint64_t flush_duration;
+ uintnat n = eb->ev_generated;
+
+ struct ctf_event_header ev_flush;
+ ev_flush.id = EV_FLUSH;
+ ev_flush.timestamp = time_counter() -
+ Caml_state->eventlog_startup_timestamp;
+ ev_flush.pid = Caml_state->eventlog_startup_pid;
+
+ for (i = 0; i < n; i++) {
+ struct event ev = eb->events[i];
+ ev.header.pid = Caml_state->eventlog_startup_pid;
+
+ FWRITE_EV(&ev.header, sizeof(struct ctf_event_header));
+
+ switch (ev.header.id)
+ {
+ case EV_ENTRY:
+ FWRITE_EV(&ev.phase, sizeof(uint16_t));
+ break;
+ case EV_EXIT:
+ FWRITE_EV(&ev.phase, sizeof(uint16_t));
+ break;
+ case EV_COUNTER:
+ FWRITE_EV(&ev.count, sizeof(uint64_t));
+ FWRITE_EV(&ev.counter_kind, sizeof(uint16_t));
+ break;
+ case EV_ALLOC:
+ FWRITE_EV(&ev.count, sizeof(uint64_t));
+ FWRITE_EV(&ev.alloc_bucket, sizeof(uint8_t));
+ break;
+ default:
+ break;
+ }
+ }
+
+ flush_duration =
+ (time_counter() - Caml_state->eventlog_startup_timestamp) -
+ ev_flush.timestamp;
+
+ FWRITE_EV(&ev_flush, sizeof(struct ctf_event_header));
+ FWRITE_EV(&flush_duration, sizeof(uint64_t));
+
+ return;
+
+ fwrite_failure:
+ /* on event flush failure, shut down eventlog. */
+ if (caml_runtime_warnings_active())
+ fprintf(stderr,
+ "[ocaml] error while writing trace file, disabling eventlog\n");
+ caml_eventlog_disable();
+ return;
+
+}
+
+static void teardown_eventlog(void)
+{
+ if (evbuf) {
+ if (Caml_state->eventlog_out)
+ flush_events(Caml_state->eventlog_out, evbuf);
+ caml_stat_free(evbuf);
+ evbuf = NULL;
+ }
+ if (Caml_state->eventlog_out) {
+ fclose(Caml_state->eventlog_out);
+ Caml_state->eventlog_out = NULL;
+ }
+}
+
+void caml_eventlog_init()
+{
+ char_os *toggle = caml_secure_getenv(T("OCAML_EVENTLOG_ENABLED"));
+
+ if (toggle != NULL) {
+ Caml_state->eventlog_enabled = 1;
+ if (*toggle == 'p')
+ Caml_state->eventlog_paused = 1;
+ };
+
+ if (!Caml_state->eventlog_enabled) return;
+
+ Caml_state->eventlog_startup_timestamp = time_counter();
+#ifdef _WIN32
+ Caml_state->eventlog_startup_pid = _getpid();
+#else
+ Caml_state->eventlog_startup_pid = getpid();
+#endif
+
+ setup_eventlog_file();
+ setup_evbuf();
+
+ atexit(&teardown_eventlog);
+}
+
+static void post_event(ev_gc_phase phase, ev_gc_counter counter_kind,
+ uint8_t bucket, uint64_t count, ev_type ty)
+{
+ uintnat i;
+ struct event* ev;
+
+ if (!Caml_state->eventlog_enabled) return;
+ if (Caml_state->eventlog_paused) return;
+
+ i = evbuf->ev_generated;
+ CAMLassert(i <= EVENT_BUF_SIZE);
+ if (i == EVENT_BUF_SIZE) {
+ flush_events(Caml_state->eventlog_out, evbuf);
+ evbuf->ev_generated = 0;
+ i = 0;
+ }
+ ev = &evbuf->events[i];
+ ev->header.id = ty;
+ ev->count = count;
+ ev->counter_kind = counter_kind;
+ ev->alloc_bucket = bucket;
+ ev->phase = phase;
+ ev->header.timestamp = time_counter() -
+ Caml_state->eventlog_startup_timestamp;
+ evbuf->ev_generated = i + 1;
+}
+
+void caml_ev_begin(ev_gc_phase phase)
+{
+ post_event(phase, 0, 0, 0, EV_ENTRY);
+}
+
+void caml_ev_end(ev_gc_phase phase)
+{
+ post_event(phase, 0, 0, 0, EV_EXIT);
+}
+
+void caml_ev_counter(ev_gc_counter counter, uint64_t val)
+{
+ post_event(0, counter, 0, val, EV_COUNTER);
+}
+
+static uint64_t alloc_buckets [20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+
+/* This function records allocations in caml_alloc_shr_aux in given bucket sizes
+ These buckets are meant to be flushed explicitly by the caller through the
+ caml_ev_alloc_flush function. Until then the buckets are just updated until
+ flushed.
+*/
+void caml_ev_alloc(uint64_t sz)
+{
+ if (!Caml_state->eventlog_enabled) return;
+ if (Caml_state->eventlog_paused) return;
+
+ if (sz < 10) {
+ ++alloc_buckets[sz];
+ } else if (sz < 100) {
+ ++alloc_buckets[sz/10 + 9];
+ } else {
+ ++alloc_buckets[19];
+ }
+}
+
+/* Note that this function does not trigger an actual disk flush, it just
+ pushes events in the event buffer.
+*/
+void caml_ev_alloc_flush()
+{
+ int i;
+
+ if (!Caml_state->eventlog_enabled) return;
+ if (Caml_state->eventlog_paused) return;
+
+ for (i = 1; i < 20; i++) {
+ if (alloc_buckets[i] != 0) {
+ post_event(0, 0, i, alloc_buckets[i], EV_ALLOC);
+ };
+ alloc_buckets[i] = 0;
+ }
+}
+
+void caml_ev_flush()
+{
+ if (!Caml_state->eventlog_enabled) return;
+ if (Caml_state->eventlog_paused) return;
+
+ if (Caml_state->eventlog_out) {
+ if (evbuf)
+ flush_events(Caml_state->eventlog_out, evbuf);
+ fflush(Caml_state->eventlog_out);
+ };
+}
+
+void caml_eventlog_disable()
+{
+ Caml_state->eventlog_enabled = 0;
+ teardown_eventlog();
+}
+
+CAMLprim value caml_eventlog_resume(value v)
+{
+ CAMLassert(v == Val_unit);
+ if (Caml_state->eventlog_enabled)
+ Caml_state->eventlog_paused = 0;
+ return Val_unit;
+}
+
+CAMLprim value caml_eventlog_pause(value v)
+{
+ CAMLassert(v == Val_unit);
+ if (Caml_state->eventlog_enabled) {
+ Caml_state->eventlog_paused = 1;
+ if (evbuf && Caml_state->eventlog_out)
+ flush_events(Caml_state->eventlog_out, evbuf);
+ };
+ return Val_unit;
+}
+
+#else
+
+CAMLprim value caml_eventlog_resume(value v)
+{
+ return Val_unit;
+}
+
+CAMLprim value caml_eventlog_pause(value v)
+{
+ return Val_unit;
+}
+
+#endif /*CAML_INSTR*/
static int extern_flags; /* logical or of some of the flags above */
-/* Trail mechanism to undo forwarding pointers put inside objects */
-
-struct trail_entry {
- value obj; /* address of object + initial color in low 2 bits */
- value field0; /* initial contents of field 0 */
-};
-
-struct trail_block {
- struct trail_block * previous;
- struct trail_entry entries[ENTRIES_PER_TRAIL_BLOCK];
-};
-
-static struct trail_block extern_trail_first;
-static struct trail_block * extern_trail_block;
-static struct trail_entry * extern_trail_cur, * extern_trail_limit;
-
-
/* Stack for pending values to marshal */
struct extern_item { value * v; mlsize_t count; };
static struct extern_item * extern_stack_limit = extern_stack_init
+ EXTERN_STACK_INIT_SIZE;
+/* Hash table to record already-marshaled objects and their positions */
+
+struct object_position { value obj; uintnat pos; };
+
+/* The hash table uses open addressing, linear probing, and a redundant
+ representation:
+ - a bitvector [present] records which entries of the table are occupied;
+ - an array [entries] records (object, position) pairs for the entries
+ that are occupied.
+ The bitvector is much smaller than the array (1/128th on 64-bit
+ platforms, 1/64th on 32-bit platforms), so it has better locality,
+ making it faster to determine that an object is not in the table.
+ Also, it makes it faster to empty or initialize a table: only the
+ [present] bitvector needs to be filled with zeros, the [entries]
+ array can be left uninitialized.
+*/
+
+struct position_table {
+ int shift;
+ mlsize_t size; /* size == 1 << (wordsize - shift) */
+ mlsize_t mask; /* mask == size - 1 */
+ mlsize_t threshold; /* threshold == a fixed fraction of size */
+ uintnat * present; /* [Bitvect_size(size)] */
+ struct object_position * entries; /* [size] */
+};
+
+#define Bits_word (8 * sizeof(uintnat))
+#define Bitvect_size(n) (((n) + Bits_word - 1) / Bits_word)
+
+#define POS_TABLE_INIT_SIZE_LOG2 8
+#define POS_TABLE_INIT_SIZE (1 << POS_TABLE_INIT_SIZE_LOG2)
+
+static uintnat pos_table_present_init[Bitvect_size(POS_TABLE_INIT_SIZE)];
+static struct object_position pos_table_entries_init[POS_TABLE_INIT_SIZE];
+
+static struct position_table pos_table;
+
/* Forward declarations */
CAMLnoreturn_start
static void extern_stack_overflow(void)
CAMLnoreturn_end;
-static void extern_replay_trail(void);
static void free_extern_output(void);
/* Free the extern stack if needed */
return newstack + sp_offset;
}
-/* Initialize the trail */
+/* Multiplicative Fibonacci hashing
+ (Knuth, TAOCP vol 3, section 6.4, page 518).
+ HASH_FACTOR is (sqrt(5) - 1) / 2 * 2^wordsize. */
+#ifdef ARCH_SIXTYFOUR
+#define HASH_FACTOR 11400714819323198486UL
+#else
+#define HASH_FACTOR 2654435769UL
+#endif
+#define Hash(v) (((uintnat)(v) * HASH_FACTOR) >> pos_table.shift)
+
+/* When the table becomes 2/3 full, its size is increased. */
+#define Threshold(sz) (((sz) * 2) / 3)
-static void init_extern_trail(void)
+/* Initialize the position table */
+
+static void extern_init_position_table(void)
{
- extern_trail_block = &extern_trail_first;
- extern_trail_cur = extern_trail_block->entries;
- extern_trail_limit = extern_trail_block->entries + ENTRIES_PER_TRAIL_BLOCK;
+ if (extern_flags & NO_SHARING) return;
+ pos_table.size = POS_TABLE_INIT_SIZE;
+ pos_table.shift = 8 * sizeof(value) - POS_TABLE_INIT_SIZE_LOG2;
+ pos_table.mask = POS_TABLE_INIT_SIZE - 1;
+ pos_table.threshold = Threshold(POS_TABLE_INIT_SIZE);
+ pos_table.present = pos_table_present_init;
+ pos_table.entries = pos_table_entries_init;
+ memset(pos_table_present_init, 0, sizeof(pos_table_present_init));
}
-/* Replay the trail, undoing the in-place modifications
- performed on objects */
+/* Free the position table */
-static void extern_replay_trail(void)
+static void extern_free_position_table(void)
{
- struct trail_block * blk, * prevblk;
- struct trail_entry * ent, * lim;
+ if (pos_table.present != pos_table_present_init) {
+ caml_stat_free(pos_table.present);
+ caml_stat_free(pos_table.entries);
+ /* Protect against repeated calls to extern_free_position_table */
+ pos_table.present = pos_table_present_init;
+ }
+}
- blk = extern_trail_block;
- lim = extern_trail_cur;
- while (1) {
- for (ent = &(blk->entries[0]); ent < lim; ent++) {
- value obj = ent->obj;
- color_t colornum = obj & 3;
- obj = obj & ~3;
- Hd_val(obj) = Coloredhd_hd(Hd_val(obj), colornum);
- Field(obj, 0) = ent->field0;
+/* Accessing bitvectors */
+
+Caml_inline uintnat bitvect_test(uintnat * bv, uintnat i)
+{
+ return bv[i / Bits_word] & ((uintnat) 1 << (i & (Bits_word - 1)));
+}
+
+Caml_inline void bitvect_set(uintnat * bv, uintnat i)
+{
+ bv[i / Bits_word] |= ((uintnat) 1 << (i & (Bits_word - 1)));
+}
+
+/* Grow the position table */
+
+static void extern_resize_position_table(void)
+{
+ mlsize_t new_size, new_byte_size;
+ int new_shift;
+ uintnat * new_present;
+ struct object_position * new_entries;
+ uintnat i, h;
+ struct position_table old = pos_table;
+
+ /* Grow the table quickly (x 8) up to 10^6 entries,
+ more slowly (x 2) afterwards. */
+ if (old.size < 1000000) {
+ new_size = 8 * old.size;
+ new_shift = old.shift - 3;
+ } else {
+ new_size = 2 * old.size;
+ new_shift = old.shift - 1;
+ }
+ if (new_size == 0
+ || caml_umul_overflow(new_size, sizeof(struct object_position),
+ &new_byte_size))
+ extern_out_of_memory();
+ new_entries = caml_stat_alloc_noexc(new_byte_size);
+ if (new_entries == NULL) extern_out_of_memory();
+ new_present =
+ caml_stat_calloc_noexc(Bitvect_size(new_size), sizeof(uintnat));
+ if (new_present == NULL) {
+ caml_stat_free(new_entries);
+ extern_out_of_memory();
+ }
+ pos_table.size = new_size;
+ pos_table.shift = new_shift;
+ pos_table.mask = new_size - 1;
+ pos_table.threshold = Threshold(new_size);
+ pos_table.present = new_present;
+ pos_table.entries = new_entries;
+
+ /* Insert every entry of the old table in the new table */
+ for (i = 0; i < old.size; i++) {
+ if (! bitvect_test(old.present, i)) continue;
+ h = Hash(old.entries[i].obj);
+ while (bitvect_test(new_present, h)) {
+ h = (h + 1) & pos_table.mask;
}
- if (blk == &extern_trail_first) break;
- prevblk = blk->previous;
- caml_stat_free(blk);
- blk = prevblk;
- lim = &(blk->entries[ENTRIES_PER_TRAIL_BLOCK]);
+ bitvect_set(new_present, h);
+ new_entries[h] = old.entries[i];
+ }
+
+ /* Free the old tables if not statically allocated */
+ if (old.present != pos_table_present_init) {
+ caml_stat_free(old.present);
+ caml_stat_free(old.entries);
}
- /* Protect against a second call to extern_replay_trail */
- extern_trail_block = &extern_trail_first;
- extern_trail_cur = extern_trail_block->entries;
}
-/* Set forwarding pointer on an object and add corresponding entry
- to the trail. */
+/* Determine whether the given object [obj] is in the hash table.
+ If so, set [*pos_out] to its position in the output and return 1.
+ If not, set [*h_out] to the hash value appropriate for
+ [extern_record_location] and return 0. */
-static void extern_record_location(value obj)
+Caml_inline int extern_lookup_position(value obj,
+ uintnat * pos_out, uintnat * h_out)
{
- header_t hdr;
+ uintnat h = Hash(obj);
+ while (1) {
+ if (! bitvect_test(pos_table.present, h)) {
+ *h_out = h;
+ return 0;
+ }
+ if (pos_table.entries[h].obj == obj) {
+ *pos_out = pos_table.entries[h].pos;
+ return 1;
+ }
+ h = (h + 1) & pos_table.mask;
+ }
+}
+
+/* Record the output position for the given object [obj]. */
+/* The [h] parameter is the index in the hash table where the object
+ must be inserted. It was determined during lookup. */
+static void extern_record_location(value obj, uintnat h)
+{
if (extern_flags & NO_SHARING) return;
- if (extern_trail_cur == extern_trail_limit) {
- struct trail_block * new_block =
- caml_stat_alloc_noexc(sizeof(struct trail_block));
- if (new_block == NULL) extern_out_of_memory();
- new_block->previous = extern_trail_block;
- extern_trail_block = new_block;
- extern_trail_cur = extern_trail_block->entries;
- extern_trail_limit = extern_trail_block->entries + ENTRIES_PER_TRAIL_BLOCK;
- }
- hdr = Hd_val(obj);
- extern_trail_cur->obj = obj | Colornum_hd(hdr);
- extern_trail_cur->field0 = Field(obj, 0);
- extern_trail_cur++;
- Hd_val(obj) = Bluehd_hd(hdr);
- Field(obj, 0) = (value) obj_counter;
+ bitvect_set(pos_table.present, h);
+ pos_table.entries[h].obj = obj;
+ pos_table.entries[h].pos = obj_counter;
obj_counter++;
+ if (obj_counter >= pos_table.threshold) extern_resize_position_table();
}
/* To buffer the output */
{
struct output_block * blk, * nextblk;
- if (extern_userprovided_output != NULL) return;
- for (blk = extern_output_first; blk != NULL; blk = nextblk) {
- nextblk = blk->next;
- caml_stat_free(blk);
+ if (extern_userprovided_output == NULL) {
+ for (blk = extern_output_first; blk != NULL; blk = nextblk) {
+ nextblk = blk->next;
+ caml_stat_free(blk);
+ }
+ extern_output_first = NULL;
}
- extern_output_first = NULL;
extern_free_stack();
+ extern_free_position_table();
}
static void grow_extern_output(intnat required)
static void extern_out_of_memory(void)
{
- extern_replay_trail();
free_extern_output();
caml_raise_out_of_memory();
}
static void extern_invalid_argument(char *msg)
{
- extern_replay_trail();
free_extern_output();
caml_invalid_argument(msg);
}
static void extern_failwith(char *msg)
{
- extern_replay_trail();
free_extern_output();
caml_failwith(msg);
}
static void extern_stack_overflow(void)
{
caml_gc_message (0x04, "Stack overflow in marshaling value\n");
- extern_replay_trail();
free_extern_output();
caml_raise_out_of_memory();
}
/* Conversion to big-endian */
-static inline void store16(char * dst, int n)
+Caml_inline void store16(char * dst, int n)
{
dst[0] = n >> 8; dst[1] = n;
}
-static inline void store32(char * dst, intnat n)
+Caml_inline void store32(char * dst, intnat n)
{
dst[0] = n >> 24; dst[1] = n >> 16; dst[2] = n >> 8; dst[3] = n;
}
-static inline void store64(char * dst, int64_t n)
+Caml_inline void store64(char * dst, int64_t n)
{
dst[0] = n >> 56; dst[1] = n >> 48; dst[2] = n >> 40; dst[3] = n >> 32;
dst[4] = n >> 24; dst[5] = n >> 16; dst[6] = n >> 8; dst[7] = n;
/* Write characters, integers, and blocks in the output buffer */
-static inline void write(int c)
+Caml_inline void write(int c)
{
if (extern_ptr >= extern_limit) grow_extern_output(1);
*extern_ptr++ = c;
extern_ptr += len;
}
-static inline void writeblock_float8(const double * data, intnat ndoubles)
+Caml_inline void writeblock_float8(const double * data, intnat ndoubles)
{
#if ARCH_FLOAT_ENDIANNESS == 0x01234567 || ARCH_FLOAT_ENDIANNESS == 0x76543210
writeblock((const char *) data, ndoubles * 8);
{
struct code_fragment * cf;
struct extern_item * sp;
+ uintnat h = 0;
+ uintnat pos = 0;
+
+ extern_init_position_table();
sp = extern_stack;
while(1) {
}
goto next_item;
}
- /* Check if already seen */
- if (Color_hd(hd) == Caml_blue) {
- uintnat d = obj_counter - (uintnat) Field(v, 0);
- if (d < 0x100) {
- writecode8(CODE_SHARED8, d);
- } else if (d < 0x10000) {
- writecode16(CODE_SHARED16, d);
+ /* Check if object already seen */
+ if (! (extern_flags & NO_SHARING)) {
+ if (extern_lookup_position(v, &pos, &h)) {
+ uintnat d = obj_counter - pos;
+ if (d < 0x100) {
+ writecode8(CODE_SHARED8, d);
+ } else if (d < 0x10000) {
+ writecode16(CODE_SHARED16, d);
#ifdef ARCH_SIXTYFOUR
- } else if (d >= (uintnat)1 << 32) {
- writecode64(CODE_SHARED64, d);
+ } else if (d >= (uintnat)1 << 32) {
+ writecode64(CODE_SHARED64, d);
#endif
- } else {
- writecode32(CODE_SHARED32, d);
+ } else {
+ writecode32(CODE_SHARED32, d);
+ }
+ goto next_item;
}
- goto next_item;
}
/* Output the contents of the object */
writeblock(String_val(v), len);
size_32 += 1 + (len + 4) / 4;
size_64 += 1 + (len + 8) / 8;
- extern_record_location(v);
+ extern_record_location(v, h);
break;
}
case Double_tag: {
writeblock_float8((double *) v, 1);
size_32 += 1 + 2;
size_64 += 1 + 1;
- extern_record_location(v);
+ extern_record_location(v, h);
break;
}
case Double_array_tag: {
writeblock_float8((double *) v, nfloats);
size_32 += 1 + nfloats * 2;
size_64 += 1 + nfloats;
- extern_record_location(v);
+ extern_record_location(v, h);
break;
}
case Abstract_tag:
}
size_32 += 2 + ((sz_32 + 3) >> 2); /* header + ops + data */
size_64 += 2 + ((sz_64 + 7) >> 3);
- extern_record_location(v);
+ extern_record_location(v, h);
break;
}
default: {
size_32 += 1 + sz;
size_64 += 1 + sz;
field0 = Field(v, 0);
- extern_record_location(v);
+ extern_record_location(v, h);
/* Remember that we still have to serialize fields 1 ... sz - 1 */
if (sz > 1) {
sp++;
if (sp == extern_stack) {
/* We are done. Cleanup the stack and leave the function */
extern_free_stack();
+ extern_free_position_table();
return;
}
v = *((sp->v)++);
/* Parse flag list */
extern_flags = caml_convert_flag_list(flags, extern_flag_values);
/* Initializations */
- init_extern_trail();
obj_counter = 0;
size_32 = 0;
size_64 = 0;
extern_rec(v);
/* Record end of output */
close_extern_output();
- /* Undo the modifications done on externed blocks */
- extern_replay_trail();
/* Write the header */
res_len = extern_output_length();
#ifdef ARCH_SIXTYFOUR
int header_len;
intnat data_len;
char * res;
- struct output_block * blk;
+ struct output_block * blk, * nextblk;
init_extern_output();
data_len = extern_value(v, flags, header, &header_len);
*len = header_len + data_len;
memcpy(res, header, header_len);
res += header_len;
- for (blk = extern_output_first; blk != NULL; blk = blk->next) {
+ for (blk = extern_output_first; blk != NULL; blk = nextblk) {
intnat n = blk->end - blk->data;
memcpy(res, blk->data, n);
res += n;
+ nextblk = blk->next;
+ caml_stat_free(blk);
}
- free_extern_output();
}
/* Functions for writing user-defined marshallers */
}
}
-static inline value caml_get_failwith_tag (char const *msg)
+Caml_inline value caml_get_failwith_tag (char const *msg)
{
check_global_data_param("Failure", msg);
return Field(caml_global_data, FAILURE_EXN);
CAMLnoreturn;
}
-static inline value caml_get_invalid_argument_tag (char const *msg)
+Caml_inline value caml_get_invalid_argument_tag (char const *msg)
{
check_global_data_param("Invalid_argument", msg);
return Field(caml_global_data, INVALID_EXN);
/* This branchless implementation is from GPR#164.
Note that [f == f] if and only if f is not NaN.
We expand each subresult of the expression to
- avoid sign-extension on 64bit. GPR#2250. */
+ avoid sign-extension on 64bit. GPR#2250.
+ See also translation of Pcompare_floats in asmcomp/cmmgen.ml */
intnat res =
(intnat)(f > g) - (intnat)(f < g) + (intnat)(f == f) - (intnat)(g == g);
return res;
#include "caml/major_gc.h"
#include "caml/misc.h"
#include "caml/mlvalues.h"
+#include "caml/eventlog.h"
/*************** declarations common to all policies ******************/
#define Next_small(v) Field ((v), 0)
/* Next in memory order */
-static inline value Next_in_mem (value v) {
+Caml_inline value Next_in_mem (value v) {
return (value) &Field ((v), Whsize_val (v));
}
#ifdef CAML_INSTR
-static uintnat instr_size [20] =
- {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
-static char *instr_name [20] = {
- NULL,
- "alloc01@",
- "alloc02@",
- "alloc03@",
- "alloc04@",
- "alloc05@",
- "alloc06@",
- "alloc07@",
- "alloc08@",
- "alloc09@",
- "alloc10-19@",
- "alloc20-29@",
- "alloc30-39@",
- "alloc40-49@",
- "alloc50-59@",
- "alloc60-69@",
- "alloc70-79@",
- "alloc80-89@",
- "alloc90-99@",
- "alloc_large@",
-};
-uintnat caml_instr_alloc_jump = 0;
-/* number of pointers followed to allocate from the free set */
-
-#define INSTR_alloc_jump(n) (caml_instr_alloc_jump += (n))
-#else
+/* number of pointers followed to allocate from the free set */
+uintnat caml_instr_alloc_jump = 0;
-#define INSTR_alloc_jump(n) ((void)0)
+#define EV_ALLOC_JUMP(n) (caml_instr_alloc_jump += (n))
#endif /*CAML_INSTR*/
+
/********************* next-fit allocation policy *********************/
/* The free-list is kept sorted by increasing addresses.
value cur = Val_NULL, prev;
CAMLassert (sizeof (char *) == sizeof (value));
CAMLassert (wo_sz >= 1);
-#ifdef CAML_INSTR
- if (wo_sz < 10){
- ++instr_size[wo_sz];
- }else if (wo_sz < 100){
- ++instr_size[wo_sz/10 + 9];
- }else{
- ++instr_size[19];
- }
-#endif /* CAML_INSTR */
CAMLassert (nf_prev != Val_NULL);
/* Search from [nf_prev] to the end of the list. */
}
prev = cur;
cur = Next_small (prev);
-#ifdef CAML_INSTR
- ++ caml_instr_alloc_jump;
-#endif
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1));
}
nf_last = prev;
/* Search from the start of the list to [nf_prev]. */
}
prev = cur;
cur = Next_small (prev);
-#ifdef CAML_INSTR
- ++ caml_instr_alloc_jump;
-#endif
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1));
}
/* No suitable block was found. */
return NULL;
static void nf_init_merge (void)
{
-#ifdef CAML_INSTR
- int i;
- for (i = 1; i < 20; i++){
- CAML_INSTR_INT (instr_name[i], instr_size[i]);
- instr_size[i] = 0;
- }
-#endif /* CAML_INSTR */
+ CAML_EV_ALLOC_FLUSH();
nf_last_fragment = NULL;
caml_fl_merge = Nf_head;
#ifdef DEBUG
mlsize_t sz, prevsz;
CAMLassert (sizeof (char *) == sizeof (value));
CAMLassert (wo_sz >= 1);
-#ifdef CAML_INSTR
- if (wo_sz < 10){
- ++instr_size[wo_sz];
- }else if (wo_sz < 100){
- ++instr_size[wo_sz/10 + 9];
- }else{
- ++instr_size[19];
- }
-#endif /* CAML_INSTR */
/* Search in the flp array. */
for (i = 0; i < flp_size; i++){
static void ff_init_merge (void)
{
-#ifdef CAML_INSTR
- int i;
- for (i = 1; i < 20; i++){
- CAML_INSTR_INT (instr_name[i], instr_size[i]);
- instr_size[i] = 0;
- }
-#endif /* CAML_INSTR */
+ CAML_EV_ALLOC_FLUSH();
ff_last_fragment = NULL;
caml_fl_merge = Ff_head;
#ifdef DEBUG
/* Small free blocks have only one pointer to the next block.
Large free blocks have 5 fields:
tree fields:
- - node flag
- - left son
- - right son
+ - isnode flag
+ - left child
+ - right child
list fields:
- next
- prev
struct large_free_block *next;
} large_free_block;
-static inline mlsize_t bf_large_wosize (struct large_free_block *n) {
+Caml_inline mlsize_t bf_large_wosize (struct large_free_block *n) {
return Wosize_val((value)(n));
}
#include <strings.h>
#elif defined(HAS_BITSCANFORWARD)
#include <intrin.h>
-static inline int ffs (int x)
+Caml_inline int ffs (int x)
{
unsigned long index;
unsigned char result;
return result ? (int) index + 1 : 0;
}
#else
-static inline int ffs (int x)
+Caml_inline int ffs (int x)
{
/* adapted from Hacker's Delight */
int bnz, b0, b1, b2, b3, b4;
#endif /* HAS_FFS or HAS_BITSCANFORWARD */
/* Indexing starts at 1 because that's the minimum block size. */
-static inline void set_map (int index)
+Caml_inline void set_map (int index)
{
bf_small_map |= (1 << (index - 1));
}
-static inline void unset_map (int index)
+Caml_inline void unset_map (int index)
{
bf_small_map &= ~(1 << (index - 1));
}
}else{
CAMLassert (caml_gc_phase != Phase_sweep
|| caml_fl_merge == Val_NULL
- || Val_bp (bf_small_fl[i].merge) < caml_fl_merge);
+ || bf_small_fl[i].merge < &Next_small(caml_fl_merge));
}
CAMLassert (*bf_small_fl[i].merge == Val_NULL
|| Color_val (*bf_small_fl[i].merge) == Caml_blue);
while (1){
cur = *p;
- INSTR_alloc_jump (1);
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1));
if (cur == NULL) break;
cursz = bf_large_wosize (cur);
if (cursz == wosz){
return p;
}
-/* Search for the least node that is large enough to accomodate the given
+/* Search for the least node that is large enough to accommodate the given
size. Return in [next_lower] an upper bound on either the size of the
next-lower node in the tree, or BF_NUM_SMALL if there is no such node.
*/
while (1){
cur = *p;
- INSTR_alloc_jump (1);
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1));
if (cur == NULL){
*next_lower = lowsz;
break;
if (xsz > wosz){
/* zig */
y = x->left;
- INSTR_alloc_jump (1);
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1));
if (y == NULL) break;
if (bf_large_wosize (y) > wosz){
/* zig-zig: rotate right */
y->right = x;
x = y;
y = x->left;
- INSTR_alloc_jump (2);
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (2));
if (y == NULL) break;
}
/* link right */
CAMLassert (xsz < wosz);
/* zag */
y = x->right;
- INSTR_alloc_jump (1);
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1));
if (y == NULL) break;
if (bf_large_wosize (y) < wosz){
/* zag-zag : rotate left */
y->left = x;
x = y;
y = x->right;
- INSTR_alloc_jump (2);
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (2));
if (y == NULL) break;
}
/* link left */
*right_bottom = x->right;
x->left = left_top;
x->right = right_top;
- INSTR_alloc_jump (2);
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (2));
bf_large_tree = x;
}
large_free_block **right_bottom = &right_top;
x = *p;
- INSTR_alloc_jump (1);
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1));
CAMLassert (x != NULL);
while (1){
/* We are always in the zig case. */
y = x->left;
- INSTR_alloc_jump (1);
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1));
if (y == NULL) break;
/* And in the zig-zig case. rotate right */
x->left = y->right;
y->right = x;
x = y;
y = x->left;
- INSTR_alloc_jump (2);
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (2));
if (y == NULL) break;
/* link right */
*right_bottom = x;
/* reassemble the tree */
CAMLassert (x->left == NULL);
*right_bottom = x->right;
- INSTR_alloc_jump (1);
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1));
x->right = right_top;
*p = x;
}
large_free_block *l, *r;
x = *p;
- INSTR_alloc_jump (1);
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1));
if (x == NULL) return;
if (x == bf_large_least) bf_large_least = NULL;
l = x->left;
r = x->right;
- INSTR_alloc_jump (2);
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (2));
if (l == NULL){
*p = r;
}else if (r == NULL){
mlsize_t sz = bf_large_wosize (n);
large_free_block **p = bf_search (sz);
large_free_block *x = *p;
- INSTR_alloc_jump (1);
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (1));
if (bf_large_least != NULL){
mlsize_t least_sz = bf_large_wosize (bf_large_least);
n->next = x;
x->prev->next = n;
x->prev = n;
- INSTR_alloc_jump (2);
+ CAML_EVENTLOG_DO(EV_ALLOC_JUMP (2));
bf_splay (sz);
}
}
CAMLassert (sizeof (char *) == sizeof (value));
CAMLassert (wosz >= 1);
-#ifdef CAML_INSTR
- if (wosz < 10){
- ++instr_size[wosz];
- }else if (wosz < 100){
- ++instr_size[wosz/10 + 9];
- }else{
- ++instr_size[19];
- }
-#endif /* CAML_INSTR */
-
if (wosz <= BF_NUM_SMALL){
if (bf_small_fl[wosz].free != Val_NULL){
/* fast path: allocate from the corresponding free list */
{
mlsize_t i;
-#ifdef CAML_INSTR
- for (i = 1; i < 20; i++){
- CAML_INSTR_INT (instr_name[i], instr_size[i]);
- instr_size[i] = 0;
- }
-#endif /* CAML_INSTR */
+ CAML_EV_ALLOC_FLUSH();
caml_fl_merge = Val_NULL;
#include "caml/misc.h"
#include "caml/mlvalues.h"
#include "caml/signals.h"
+#include "caml/eventlog.h"
#ifdef NATIVE_CODE
#include "caml/stack.h"
#else
CAMLprim value caml_gc_stat(value v)
{
value result;
- CAML_INSTR_SETUP (tmr, "");
+ CAML_EV_BEGIN(EV_EXPLICIT_GC_STAT);
CAMLassert (v == Val_unit);
result = heap_stats (1);
- CAML_INSTR_TIME (tmr, "explicit/gc_stat");
+ CAML_EV_END(EV_EXPLICIT_GC_STAT);
return result;
}
asize_t newminwsz;
uintnat newpolicy;
uintnat new_custom_maj, new_custom_min, new_custom_sz;
- CAML_INSTR_SETUP (tmr, "");
+ CAML_EV_BEGIN(EV_EXPLICIT_GC_SET);
caml_verb_gc = Long_val (Field (v, 3));
ARCH_SIZET_PRINTF_FORMAT "uk words\n", newminwsz / 1024);
caml_set_minor_heap_size (Bsize_wsize (newminwsz));
}
- CAML_INSTR_TIME (tmr, "explicit/gc_set");
+ CAML_EV_END(EV_EXPLICIT_GC_SET);
/* The compaction may have triggered some finalizers that we need to call. */
caml_process_pending_actions();
CAMLprim value caml_gc_minor(value v)
{
- CAML_INSTR_SETUP (tmr, "");
+ value exn;
+
+ CAML_EV_BEGIN(EV_EXPLICIT_GC_MINOR);
CAMLassert (v == Val_unit);
caml_request_minor_gc ();
// call the gc and call finalisers
- caml_process_pending_actions();
- CAML_INSTR_TIME (tmr, "explicit/gc_minor");
+ exn = caml_process_pending_actions_exn();
+ CAML_EV_END(EV_EXPLICIT_GC_MINOR);
+ caml_raise_if_exception(exn);
return Val_unit;
}
CAMLprim value caml_gc_major(value v)
{
- CAML_INSTR_SETUP (tmr, "");
+ value exn;
+
+ CAML_EV_BEGIN(EV_EXPLICIT_GC_MAJOR);
CAMLassert (v == Val_unit);
caml_gc_message (0x1, "Major GC cycle requested\n");
caml_empty_minor_heap ();
caml_finish_major_cycle ();
test_and_compact ();
// call finalisers
- caml_process_pending_actions();
- CAML_INSTR_TIME (tmr, "explicit/gc_major");
+ exn = caml_process_pending_actions_exn();
+ CAML_EV_END(EV_EXPLICIT_GC_MAJOR);
+ caml_raise_if_exception(exn);
return Val_unit;
}
CAMLprim value caml_gc_full_major(value v)
{
- CAML_INSTR_SETUP (tmr, "");
+ value exn;
+
+ CAML_EV_BEGIN(EV_EXPLICIT_GC_FULL_MAJOR);
CAMLassert (v == Val_unit);
caml_gc_message (0x1, "Full major GC cycle requested\n");
caml_empty_minor_heap ();
caml_finish_major_cycle ();
// call finalisers
- caml_process_pending_actions();
+ exn = caml_process_pending_actions_exn();
+ if (Is_exception_result(exn)) goto cleanup;
caml_empty_minor_heap ();
caml_finish_major_cycle ();
test_and_compact ();
// call finalisers
- caml_process_pending_actions();
- CAML_INSTR_TIME (tmr, "explicit/gc_full_major");
+ exn = caml_process_pending_actions_exn();
+
+cleanup:
+ CAML_EV_END(EV_EXPLICIT_GC_FULL_MAJOR);
+ caml_raise_if_exception(exn);
+
return Val_unit;
}
CAMLprim value caml_gc_major_slice (value v)
{
- CAML_INSTR_SETUP (tmr, "");
+ CAML_EV_BEGIN(EV_EXPLICIT_GC_MAJOR_SLICE);
CAMLassert (Is_long (v));
caml_major_collection_slice (Long_val (v));
- CAML_INSTR_TIME (tmr, "explicit/gc_major_slice");
+ CAML_EV_END(EV_EXPLICIT_GC_MAJOR_SLICE);
return Val_long (0);
}
CAMLprim value caml_gc_compaction(value v)
{
- CAML_INSTR_SETUP (tmr, "");
+ value exn;
+
+ CAML_EV_BEGIN(EV_EXPLICIT_GC_COMPACT);
CAMLassert (v == Val_unit);
caml_gc_message (0x10, "Heap compaction requested\n");
caml_empty_minor_heap ();
caml_finish_major_cycle ();
// call finalisers
- caml_process_pending_actions();
+ exn = caml_process_pending_actions_exn();
+ if (Is_exception_result(exn)) goto cleanup;
caml_empty_minor_heap ();
caml_finish_major_cycle ();
caml_compact_heap (-1);
// call finalisers
- caml_process_pending_actions();
- CAML_INSTR_TIME (tmr, "explicit/gc_compact");
+ exn = caml_process_pending_actions_exn();
+
+ cleanup:
+ CAML_EV_END(EV_EXPLICIT_GC_COMPACT);
+ caml_raise_if_exception(exn);
return Val_unit;
}
major_bsize = Bsize_wsize(major_size);
major_bsize = ((major_bsize + Page_size - 1) >> Page_log) << Page_log;
- caml_instr_init ();
if (caml_page_table_initialize(Bsize_wsize(minor_size) + major_bsize)){
caml_fatal_error ("cannot initialize page table");
}
for prim in \
alloc array compare extern floats gc_ctrl hash intern interp ints io \
lexing md5 meta memprof obj parsing signals str sys callback weak \
- finalise stacks dynlink backtrace_byt backtrace spacetime_byt afl bigarray
+ finalise stacks dynlink backtrace_byt backtrace spacetime_byt afl \
+ bigarray eventlog
do
sed -n -e 's/^CAMLprim value \([a-z0-9_][a-z0-9_]*\).*/\1/p' "$prim.c"
done
FUNCTION(caml_call_gc)
CFI_STARTPROC
+LBL(caml_call_gc):
/* Record lowest stack address and return address */
- pushl %ebx; CFI_ADJUST(4)
movl G(Caml_state), %ebx
- movl 4(%esp), %eax
+ movl (%esp), %eax
movl %eax, CAML_STATE(last_return_address, %ebx)
- leal 8(%esp), %eax
+ leal 4(%esp), %eax
movl %eax, CAML_STATE(bottom_of_stack, %ebx)
- popl %ebx; CFI_ADJUST(-4)
-LBL(105):
#if !defined(SYS_mingw) && !defined(SYS_cygwin)
/* Touch the stack to trigger a recoverable segfault
if insufficient space remains */
pushl %ecx; CFI_ADJUST(4)
pushl %ebx; CFI_ADJUST(4)
pushl %eax; CFI_ADJUST(4)
- movl G(Caml_state), %ebx
movl %esp, CAML_STATE(gc_regs, %ebx)
/* MacOSX note: 16-alignment of stack preserved at this point */
/* Call the garbage collector */
popl %esi; CFI_ADJUST(-4)
popl %edi; CFI_ADJUST(-4)
popl %ebp; CFI_ADJUST(-4)
- /* Return to caller */
+ /* Return to caller. Returns young_ptr in %eax. */
+ movl CAML_STATE(young_ptr, %ebx), %eax
ret
CFI_ENDPROC
ENDFUNCTION(caml_call_gc)
FUNCTION(caml_alloc1)
CFI_STARTPROC
- pushl %ebx; CFI_ADJUST(4)
movl G(Caml_state), %ebx
movl CAML_STATE(young_ptr, %ebx), %eax
subl $8, %eax
- cmpl CAML_STATE(young_limit, %ebx), %eax
- jb LBL(100)
movl %eax, CAML_STATE(young_ptr, %ebx)
- popl %ebx; CFI_ADJUST(-4)
+ cmpl CAML_STATE(young_limit, %ebx), %eax
+ jb LBL(caml_call_gc)
ret
-LBL(100):
- movl 4(%esp), %eax
- movl %eax, CAML_STATE(last_return_address, %ebx)
- leal 8(%esp), %eax
- movl %eax, CAML_STATE(bottom_of_stack, %ebx)
- popl %ebx; CFI_ADJUST(-4)
- ALIGN_STACK(12)
- call LBL(105)
- UNDO_ALIGN_STACK(12)
- jmp G(caml_alloc1)
CFI_ENDPROC
ENDFUNCTION(caml_alloc1)
FUNCTION(caml_alloc2)
CFI_STARTPROC
- pushl %ebx; CFI_ADJUST(4)
movl G(Caml_state), %ebx
movl CAML_STATE(young_ptr, %ebx), %eax
subl $12, %eax
- cmpl CAML_STATE(young_limit, %ebx), %eax
- jb LBL(101)
movl %eax, CAML_STATE(young_ptr, %ebx)
- popl %ebx; CFI_ADJUST(-4)
+ cmpl CAML_STATE(young_limit, %ebx), %eax
+ jb LBL(caml_call_gc)
ret
-LBL(101):
- movl 4(%esp), %eax
- movl %eax, CAML_STATE(last_return_address, %ebx)
- leal 8(%esp), %eax
- movl %eax, CAML_STATE(bottom_of_stack, %ebx)
- popl %ebx; CFI_ADJUST(-4)
- ALIGN_STACK(12)
- call LBL(105)
- UNDO_ALIGN_STACK(12)
- jmp G(caml_alloc2)
CFI_ENDPROC
ENDFUNCTION(caml_alloc2)
FUNCTION(caml_alloc3)
CFI_STARTPROC
- pushl %ebx; CFI_ADJUST(4)
movl G(Caml_state), %ebx
movl CAML_STATE(young_ptr, %ebx), %eax
subl $16, %eax
- cmpl CAML_STATE(young_limit, %ebx), %eax
- jb LBL(102)
movl %eax, CAML_STATE(young_ptr, %ebx)
- popl %ebx; CFI_ADJUST(-4)
+ cmpl CAML_STATE(young_limit, %ebx), %eax
+ jb LBL(caml_call_gc)
ret
-LBL(102):
- movl 4(%esp), %eax
- movl %eax, CAML_STATE(last_return_address, %ebx)
- leal 8(%esp), %eax
- movl %eax, CAML_STATE(bottom_of_stack, %ebx)
- popl %ebx; CFI_ADJUST(-4)
- ALIGN_STACK(12)
- call LBL(105)
- UNDO_ALIGN_STACK(12)
- jmp G(caml_alloc3)
CFI_ENDPROC
ENDFUNCTION(caml_alloc3)
FUNCTION(caml_allocN)
CFI_STARTPROC
- pushl %eax; CFI_ADJUST(4) /* saved desired size */
- pushl %ebx; CFI_ADJUST(4)
movl G(Caml_state), %ebx
/* eax = size - Caml_state->young_ptr */
subl CAML_STATE(young_ptr, %ebx), %eax
negl %eax /* eax = Caml_state->young_ptr - size */
- cmpl CAML_STATE(young_limit, %ebx), %eax
- jb LBL(103)
movl %eax, CAML_STATE(young_ptr, %ebx)
- popl %ebx; CFI_ADJUST(-4)
- addl $4, %esp; CFI_ADJUST(-4) /* drop desired size */
+ cmpl CAML_STATE(young_limit, %ebx), %eax
+ jb LBL(caml_call_gc)
ret
-LBL(103):
- movl 8(%esp), %eax
- movl %eax, CAML_STATE(last_return_address, %ebx)
- leal 12(%esp), %eax
- movl %eax, CAML_STATE(bottom_of_stack, %ebx)
- popl %ebx; CFI_ADJUST(-4)
- ALIGN_STACK(8)
- call LBL(105)
- UNDO_ALIGN_STACK(8)
- popl %eax; CFI_ADJUST(-4) /* recover desired size */
- jmp G(caml_allocN)
CFI_ENDPROC
ENDFUNCTION(caml_allocN)
_caml_call_gc:
; Record lowest stack address and return address
- push ebx ; make a tmp reg
mov ebx, _Caml_state
- mov eax, [esp+4]
+ mov eax, [esp]
Store_last_return_address ebx, eax
- lea eax, [esp+8]
+ lea eax, [esp+4]
Store_bottom_of_stack ebx, eax
- pop ebx
; Save all regs used by the code generator
-L105: push ebp
+ push ebp
push edi
push esi
push edx
push ecx
push ebx
push eax
- mov ebx, _Caml_state
Store_gc_regs ebx, esp
; Call the garbage collector
call _caml_garbage_collection
pop esi
pop edi
pop ebp
- ; Return to caller
+ ; Return to caller. Returns young_ptr in eax
+ Load_young_ptr ebx, eax
ret
ALIGN 4
_caml_alloc1:
- push ebx ; make a tmp reg
mov ebx, _Caml_state
Load_young_ptr ebx, eax
sub eax, 8
- Cmp_young_limit ebx, eax
- jb L100
Store_young_ptr ebx, eax
- pop ebx
+ Cmp_young_limit ebx, eax
+ jb _caml_call_gc
ret
-L100: mov eax, [esp + 4]
- Store_last_return_address ebx, eax
- lea eax, [esp+8]
- Store_bottom_of_stack ebx, eax
- pop ebx
- call L105
- jmp _caml_alloc1
ALIGN 4
_caml_alloc2:
- push ebx ; make a tmp reg
mov ebx, _Caml_state
Load_young_ptr ebx, eax
sub eax, 12
- Cmp_young_limit ebx, eax
- jb L101
Store_young_ptr ebx, eax
- pop ebx
+ Cmp_young_limit ebx, eax
+ jb _caml_call_gc
ret
-L101: mov eax, [esp+4]
- Store_last_return_address ebx, eax
- lea eax, [esp+8]
- Store_bottom_of_stack ebx, eax
- pop ebx
- call L105
- jmp _caml_alloc2
ALIGN 4
_caml_alloc3:
- push ebx ; make a tmp reg
mov ebx, _Caml_state
Load_young_ptr ebx, eax
sub eax, 16
- Cmp_young_limit ebx, eax
- jb L102
Store_young_ptr ebx, eax
- pop ebx
+ Cmp_young_limit ebx, eax
+ jb _caml_call_gc
ret
-L102: mov eax, [esp+4]
- Store_last_return_address ebx, eax
- lea eax, [esp+8]
- Store_bottom_of_stack ebx, eax
- pop ebx
- call L105
- jmp _caml_alloc3
-
ALIGN 4
_caml_allocN:
- push eax ; Save desired size
- push ebx ; Make a tmp reg
mov ebx, _Caml_state
Sub_young_ptr ebx, eax ; eax = size - young_ptr
neg eax ; eax = young_ptr - size
- Cmp_young_limit ebx, eax
- jb L103
Store_young_ptr ebx, eax
- pop ebx
- add esp, 4 ; drop desired size
+ Cmp_young_limit ebx, eax
+ jb _caml_call_gc
ret
-L103: mov eax, [esp+8]
- Store_last_return_address ebx, eax
- lea eax, [esp+12]
- Store_bottom_of_stack ebx, eax
- pop ebx
- call L105
- pop eax ; recover desired size
- jmp _caml_allocN
; Call a C function from OCaml
static void intern_free_stack(void);
-static inline unsigned char read8u(void)
+Caml_inline unsigned char read8u(void)
{ return *intern_src++; }
-static inline signed char read8s(void)
+Caml_inline signed char read8s(void)
{ return *intern_src++; }
-static inline uint16_t read16u(void)
+Caml_inline uint16_t read16u(void)
{
uint16_t res = (intern_src[0] << 8) + intern_src[1];
intern_src += 2;
return res;
}
-static inline int16_t read16s(void)
+Caml_inline int16_t read16s(void)
{
int16_t res = (intern_src[0] << 8) + intern_src[1];
intern_src += 2;
return res;
}
-static inline uint32_t read32u(void)
+Caml_inline uint32_t read32u(void)
{
uint32_t res =
((uint32_t)(intern_src[0]) << 24) + (intern_src[1] << 16)
return res;
}
-static inline int32_t read32s(void)
+Caml_inline int32_t read32s(void)
{
int32_t res =
((uint32_t)(intern_src[0]) << 24) + (intern_src[1] << 16)
}
#endif
-static inline void readblock(void * dest, intnat len)
+Caml_inline void readblock(void * dest, intnat len)
{
memcpy(dest, intern_src, len);
intern_src += len;
// Do call asynchronous callbacks from allocation functions
#define Alloc_small_origin CAML_FROM_CAML
#define Setup_for_gc \
- { sp -= 2; sp[0] = accu; sp[1] = env; Caml_state->extern_sp = sp; }
+ { sp -= 3; sp[0] = accu; sp[1] = env; sp[2] = (value)pc; \
+ Caml_state->extern_sp = sp; }
#define Restore_after_gc \
- { accu = sp[0]; env = sp[1]; sp += 2; }
+ { sp = Caml_state->extern_sp; accu = sp[0]; env = sp[1]; sp += 3; }
/* We store [pc+1] in the stack so that, in case of an exception, the
first backtrace slot points to the event following the C call
sp[0] = accu; sp[1] = (value)(pc - 1); \
sp[2] = env; sp[3] = Val_long(extra_args); \
Caml_state->extern_sp = sp; }
-#define Restore_after_debugger { sp += 4; }
+#define Restore_after_debugger \
+ { CAMLassert(sp == Caml_state->extern_sp); \
+ CAMLassert(sp[0] == accu); \
+ CAMLassert(sp[2] == env); \
+ sp += 4; }
#ifdef THREADED_CODE
#define Restart_curr_instr \
Instruct(GETFIELD):
accu = Field(accu, *pc); pc++; Next;
Instruct(GETFLOATFIELD): {
- double d = Double_flat_field(accu, *pc);
+ double d = Double_flat_field(accu, *pc++);
Alloc_small(accu, Double_wosize, Double_tag);
Store_double_val(accu, d);
- pc++;
Next;
}
#include "caml/roots.h"
#include "caml/signals.h"
#include "caml/weak.h"
+#include "caml/memprof.h"
+#include "caml/eventlog.h"
#if defined (NATIVE_CODE) && defined (NO_NAKED_POINTERS)
#define NATIVE_CODE_AND_NO_NAKED_POINTERS
#endif
#ifdef _MSC_VER
-static inline double fmin(double a, double b) {
+Caml_inline double fmin(double a, double b) {
return (a < b) ? a : b;
}
#endif
- the ephemerons in (3) are in an unknown state and must be checked
At the end of mark phase, (3) is empty and ephe_list_pure is true.
- The ephemeron in (1) and (2) will be cleaned (white keys and datas
+ The ephemeron in (1) and (2) will be cleaned (white keys and data
replaced by none or the ephemeron is removed from the list if it is white)
in clean phase.
static value current_value = 0;
static mlsize_t current_index = 0;
-/* For instrumentation */
-#ifdef CAML_INSTR
-#define INSTR(x) x
-#else
-#define INSTR(x) /**/
-#endif
-
static void init_sweep_phase(void)
{
/* Phase_clean is done. */
}
/* auxiliary function of mark_slice */
-static inline value* mark_slice_darken(value *gray_vals_ptr,
- value v, mlsize_t i,
- int in_ephemeron, int *slice_pointers)
+Caml_inline value* mark_slice_darken(value *gray_vals_ptr,
+ value v, mlsize_t i,
+ int in_ephemeron, int *slice_pointers)
{
value child;
header_t chd;
#else
if (Is_block (child) && Is_in_heap (child)) {
#endif
- INSTR (++ *slice_pointers;)
+ CAML_EVENTLOG_DO (++ *slice_pointers);
chd = Hd_val (child);
if (Tag_hd (chd) == Forward_tag){
value f = Forward_val (child);
header_t hd;
mlsize_t size, i, start, end; /* [start] is a local copy of [current_index] */
#ifdef CAML_INSTR
- int slice_fields = 0;
-#endif
- int slice_pointers = 0; /** gcc removes it when not in CAML_INSTR */
+ int slice_fields = 0; /** eventlog counters */
+#endif /*CAML_INSTR*/
+ int slice_pointers = 0;
caml_gc_message (0x40, "Marking %"ARCH_INTNAT_PRINTF_FORMAT"d words\n", work);
caml_gc_message (0x40, "Subphase = %d\n", caml_gc_subphase);
start = size < start ? size : start;
end = size < end ? size : end;
CAMLassert (end >= start);
- INSTR (slice_fields += end - start;)
- INSTR (if (size > end)
- CAML_INSTR_INT ("major/mark/slice/remain", size - end);)
+ CAML_EVENTLOG_DO({
+ slice_fields += end - start;
+ if (size > end)
+ CAML_EV_COUNTER (EV_C_MAJOR_MARK_SLICE_REMAIN, size - end);
+ });
for (i = start; i < end; i++){
gray_vals_ptr = mark_slice_darken(gray_vals_ptr,v,i,
/*in_ephemeron=*/ 0,
markhp = chunk;
limit = chunk + Chunk_size (chunk);
} else if (caml_gc_subphase == Subphase_mark_roots) {
+ CAML_EV_BEGIN(EV_MAJOR_MARK_ROOTS);
gray_vals_cur = gray_vals_ptr;
work = caml_darken_all_roots_slice (work);
gray_vals_ptr = gray_vals_cur;
+ CAML_EV_END(EV_MAJOR_MARK_ROOTS);
if (work > 0){
caml_gc_subphase = Subphase_mark_main;
}
case Subphase_mark_main: {
/* Subphase_mark_main is done.
Mark finalised values. */
+ CAML_EV_BEGIN(EV_MAJOR_MARK_MAIN);
gray_vals_cur = gray_vals_ptr;
caml_final_update_mark_phase ();
gray_vals_ptr = gray_vals_cur;
}
/* Complete the marking */
ephes_to_check = ephes_checked_if_pure;
+ CAML_EV_END(EV_MAJOR_MARK_MAIN);
caml_gc_subphase = Subphase_mark_final;
}
break;
case Subphase_mark_final: {
/** The set of unreachable value will not change anymore for
this cycle. Start clean phase. */
+ CAML_EV_BEGIN(EV_MAJOR_MARK_FINAL);
caml_gc_phase = Phase_clean;
caml_final_update_clean_phase ();
+ caml_memprof_update_clean_phase ();
if (caml_ephe_list_head != (value) NULL){
/* Initialise the clean phase. */
ephes_to_check = &caml_ephe_list_head;
/* Initialise the sweep phase. */
init_sweep_phase();
}
- work = 0;
+ work = 0;
+ CAML_EV_END(EV_MAJOR_MARK_FINAL);
}
break;
default: CAMLassert (0);
gray_vals_cur = gray_vals_ptr;
current_value = v;
current_index = start;
- INSTR (CAML_INSTR_INT ("major/mark/slice/fields#", slice_fields);)
- INSTR (CAML_INSTR_INT ("major/mark/slice/pointers#", slice_pointers);)
+ CAML_EV_COUNTER(EV_C_MAJOR_MARK_SLICE_FIELDS, slice_fields);
+ CAML_EV_COUNTER(EV_C_MAJOR_MARK_SLICE_POINTERS, slice_pointers);
}
/* Clean ephemerons */
}
}
-#ifdef CAML_INSTR
-static char *mark_slice_name[] = {
- /* 0 */ NULL,
- /* 1 */ NULL,
- /* 2 */ NULL,
- /* 3 */ NULL,
- /* 4 */ NULL,
- /* 5 */ NULL,
- /* 6 */ NULL,
- /* 7 */ NULL,
- /* 8 */ NULL,
- /* 9 */ NULL,
- /* 10 */ "major/mark_roots",
- /* 11 */ "major/mark_main",
- /* 12 */ "major/mark_weak1",
- /* 13 */ "major/mark_weak2",
- /* 14 */ "major/mark_final",
-};
-#endif
-
/* The main entry point for the major GC. Called about once for each
minor GC. [howmuch] is the amount of work to do:
-1 if the GC is triggered automatically
*/
if (caml_major_slice_begin_hook != NULL) (*caml_major_slice_begin_hook) ();
- CAML_INSTR_SETUP (tmr, "major");
p = (double) caml_allocated_words * 3.0 * (100 + caml_percent_free)
/ Caml_state->stat_heap_wsz / caml_percent_free / 2.0;
p_backlog = p - 0.3;
p = 0.3;
}
- CAML_INSTR_INT ("major/work/extra#",
+
+ CAML_EV_COUNTER (EV_C_MAJOR_WORK_EXTRA,
(uintnat) (caml_extra_heap_resources * 1000000));
caml_gc_message (0x40, "ordered work = %"
if (Caml_state->young_ptr == Caml_state->young_alloc_end){
/* We can only start a major GC cycle if the minor allocation arena
is empty, otherwise we'd have to treat it as a set of roots. */
+ CAML_EV_BEGIN(EV_MAJOR_ROOTS);
start_cycle ();
- CAML_INSTR_TIME (tmr, "major/roots");
+ CAML_EV_END(EV_MAJOR_ROOTS);
}
p = 0;
goto finished;
caml_gc_message (0x40, "computed work = %"
ARCH_INTNAT_PRINTF_FORMAT "d words\n", computed_work);
if (caml_gc_phase == Phase_mark){
- CAML_INSTR_INT ("major/work/mark#", computed_work);
+ CAML_EV_COUNTER (EV_C_MAJOR_WORK_MARK, computed_work);
+ CAML_EV_BEGIN(EV_MAJOR_MARK);
mark_slice (computed_work);
- CAML_INSTR_TIME (tmr, mark_slice_name[caml_gc_subphase]);
+ CAML_EV_END(EV_MAJOR_MARK);
caml_gc_message (0x02, "!");
}else if (caml_gc_phase == Phase_clean){
clean_slice (computed_work);
caml_gc_message (0x02, "%%");
}else{
CAMLassert (caml_gc_phase == Phase_sweep);
- CAML_INSTR_INT ("major/work/sweep#", computed_work);
+ CAML_EV_COUNTER (EV_C_MAJOR_WORK_SWEEP, computed_work);
+ CAML_EV_BEGIN(EV_MAJOR_SWEEP);
sweep_slice (computed_work);
- CAML_INSTR_TIME (tmr, "major/sweep");
+ CAML_EV_END(EV_MAJOR_SWEEP);
caml_gc_message (0x02, "$");
}
if (caml_gc_phase == Phase_idle){
+ CAML_EV_BEGIN(EV_MAJOR_CHECK_AND_COMPACT);
caml_compact_heap_maybe ();
- CAML_INSTR_TIME (tmr, "major/check_and_compact");
+ CAML_EV_END(EV_MAJOR_CHECK_AND_COMPACT);
}
finished:
#include "caml/mlvalues.h"
#include "caml/signals.h"
#include "caml/memprof.h"
+#include "caml/eventlog.h"
int caml_huge_fallback_count = 0;
/* Number of times that mmapping big pages fails and we fell back to small
}
}
-static inline value caml_alloc_shr_aux (mlsize_t wosize, tag_t tag, int track,
- int raise_oom, uintnat profinfo)
+Caml_inline value caml_alloc_shr_aux (mlsize_t wosize, tag_t tag, int track,
+ int raise_oom, uintnat profinfo)
{
header_t *hp;
value *new_block;
else
return 0;
}
+ CAML_EV_ALLOC(wosize);
hp = caml_fl_allocate (wosize);
if (hp == NULL){
new_block = expand_heap (wosize);
profinfo));
caml_allocated_words += Whsize_wosize (wosize);
if (caml_allocated_words > Caml_state->minor_heap_wsz){
- CAML_INSTR_INT ("request_major/alloc_shr@", 1);
+ CAML_EV_COUNTER (EV_C_REQUEST_MAJOR_ALLOC_SHR, 1);
caml_request_major_slice ();
}
#ifdef DEBUG
if (res > max) res = max;
caml_extra_heap_resources += (double) res / (double) max;
if (caml_extra_heap_resources > 1.0){
- CAML_INSTR_INT ("request_major/adjust_gc_speed_1@", 1);
+ CAML_EV_COUNTER (EV_C_REQUEST_MAJOR_ADJUST_GC_SPEED, 1);
caml_extra_heap_resources = 1.0;
caml_request_major_slice ();
}
major GC treats it as an additional root.
The logic implemented below is duplicated in caml_array_fill to
- avoid repated calls to caml_modify and repeated tests on the
+ avoid repeated calls to caml_modify and repeated tests on the
values. Don't forget to update caml_array_fill if the logic
below changes!
*/
/* [sz] is a number of bytes */
CAMLexport caml_stat_block caml_stat_resize_noexc(caml_stat_block b, asize_t sz)
{
+ if(b == NULL)
+ return caml_stat_alloc_noexc(sz);
/* Backward compatibility mode */
if (pool == NULL)
return realloc(b, sz);
#include "caml/weak.h"
#include "caml/stack.h"
#include "caml/misc.h"
+#include "caml/compact.h"
+#include "caml/printexc.h"
+#include "caml/eventlog.h"
-static uint32_t mt_state[624];
+#define MT_STATE_SIZE 624
+
+static uint32_t mt_state[MT_STATE_SIZE];
static uint32_t mt_index;
/* [lambda] is the mean number of samples for each allocated word (including
Dummy if [lambda = 0]. */
static double one_log1m_lambda;
+/* [caml_memprof_suspended] is used for masking memprof callbacks when
+ a callback is running or when an uncaught exception handler is
+ called. */
int caml_memprof_suspended = 0;
-static intnat callstack_size = 0;
-static value memprof_callback = Val_unit;
+
+/* [callback_running] is used to trigger a fatal error whenever
+ [Thread.exit] is called from a callback. */
+static int callback_running = 0;
+
+static intnat callstack_size;
+
+/* accessors for the OCaml type [Gc.Memprof.tracker],
+ which is the type of the [tracker] global below. */
+#define Alloc_minor(tracker) (Field(tracker, 0))
+#define Alloc_major(tracker) (Field(tracker, 1))
+#define Promote(tracker) (Field(tracker, 2))
+#define Dealloc_minor(tracker) (Field(tracker, 3))
+#define Dealloc_major(tracker) (Field(tracker, 4))
+
+static value tracker;
+
/* Pointer to the word following the next sample in the minor
heap. Equals [Caml_state->young_alloc_start] if no sampling is planned in
/* Whether memprof has been initialized. */
static int init = 0;
+/* Whether memprof is started. */
+static int started = 0;
+
+/* Buffer used to compute backtraces */
+static value* callstack_buffer = NULL;
+static intnat callstack_buffer_len = 0;
+
/**** Statistical sampling ****/
static double mt_generate_uniform(void)
uint32_t y;
/* Mersenne twister PRNG */
- if (mt_index == 624) {
- for(i = 0; i < 227; i++) {
+ if (mt_index == MT_STATE_SIZE) {
+ for (i = 0; i < 227; i++) {
y = (mt_state[i] & 0x80000000) + (mt_state[i+1] & 0x7fffffff);
mt_state[i] = mt_state[i+397] ^ (y >> 1) ^ ((-(y&1)) & 0x9908b0df);
}
- for(i = 227; i < 623; i++) {
+ for (i = 227; i < MT_STATE_SIZE - 1; i++) {
y = (mt_state[i] & 0x80000000) + (mt_state[i+1] & 0x7fffffff);
mt_state[i] = mt_state[i-227] ^ (y >> 1) ^ ((-(y&1)) & 0x9908b0df);
}
- y = (mt_state[623] & 0x80000000) + (mt_state[0] & 0x7fffffff);
- mt_state[623] = mt_state[396] ^ (y >> 1) ^ ((-(y&1)) & 0x9908b0df);
+ y = (mt_state[MT_STATE_SIZE - 1] & 0x80000000) + (mt_state[0] & 0x7fffffff);
+ mt_state[MT_STATE_SIZE - 1] =
+ mt_state[396] ^ (y >> 1) ^ ((-(y&1)) & 0x9908b0df);
mt_index = 0;
}
}
/* Simulate a geometric variable of parameter [lambda].
- The result is clipped in [1..Max_long]
- Requires [lambda > 0]. */
-static uintnat mt_generate_geom()
+ The result is clipped in [1..Max_long] */
+static uintnat mt_generate_geom(void)
{
+ double res;
+ CAMLassert(lambda > 0.);
/* We use the float versions of exp/log, since these functions are
significantly faster, and we really don't need much precision
here. The entropy contained in [next_mt_generate_geom] is anyway
bounded by the entropy provided by [mt_generate_uniform], which
is 32bits. */
- double res = 1 + logf(mt_generate_uniform()) * one_log1m_lambda;
+ res = 1 + logf(mt_generate_uniform()) * one_log1m_lambda;
if (res > Max_long) return Max_long;
return (uintnat)res;
}
-static uintnat next_mt_generate_binom;
+static uintnat next_mt_generate_geom;
/* Simulate a binomial variable of parameters [len] and [lambda].
This sampling algorithm has running time linear with [len *
lambda]. We could use more a involved algorithm, but this should
If needed, we could use algorithm BTRS from the paper:
Hormann, Wolfgang. "The generation of binomial random variates."
Journal of statistical computation and simulation 46.1-2 (1993), pp101-110.
-
- Requires [lambda > 0] and [len < Max_long].
*/
static uintnat mt_generate_binom(uintnat len)
{
uintnat res;
- for(res = 0; next_mt_generate_binom < len; res++)
- next_mt_generate_binom += mt_generate_geom();
- next_mt_generate_binom -= len;
+ CAMLassert(lambda > 0. && len < Max_long);
+ for (res = 0; next_mt_generate_geom < len; res++)
+ next_mt_generate_geom += mt_generate_geom();
+ next_mt_generate_geom -= len;
return res;
}
-/**** Interface with the OCaml code. ****/
-
-static void purge_postponed_queue(void);
+/**** Capturing the call stack *****/
-CAMLprim value caml_memprof_set(value v)
+/* This function is called in, e.g., [caml_alloc_shr], which
+ guarantees that the GC is not called. Clients may use it in a
+ context where the heap is in an invalid state, or when the roots
+ are not properly registered. Therefore, we do not use [caml_alloc],
+ which may call the GC, but prefer using [caml_alloc_shr], which
+ gives this guarantee. The return value is either a valid callstack
+ or 0 in out-of-memory scenarios. */
+static value capture_callstack_postponed()
{
- CAMLparam1(v);
- double l = Double_val(Field(v, 0));
- intnat sz = Long_val(Field(v, 1));
+ value res;
+ intnat callstack_len =
+ caml_collect_current_callstack(&callstack_buffer, &callstack_buffer_len,
+ callstack_size, -1);
+ if (callstack_len == 0)
+ return Atom(0);
+ res = caml_alloc_shr_no_track_noexc(callstack_len, 0);
+ if (res == 0)
+ return Atom(0);
+ memcpy(Op_val(res), callstack_buffer, sizeof(value) * callstack_len);
+ if (callstack_buffer_len > 256 && callstack_buffer_len > callstack_len * 8) {
+ caml_stat_free(callstack_buffer);
+ callstack_buffer = NULL;
+ callstack_buffer_len = 0;
+ }
+ return res;
+}
- if (sz < 0 || !(l >= 0.) || l > 1.) /* Checks that [l] is not NAN. */
- caml_invalid_argument("caml_memprof_set");
+/* In this version, we are allowed to call the GC, so we use
+ [caml_alloc], which is more efficient since it uses the minor
+ heap.
+ Should be called with [caml_memprof_suspended == 1] */
+static value capture_callstack(int alloc_idx)
+{
+ value res;
+ intnat callstack_len =
+ caml_collect_current_callstack(&callstack_buffer, &callstack_buffer_len,
+ callstack_size, alloc_idx);
+ CAMLassert(caml_memprof_suspended);
+ res = caml_alloc(callstack_len, 0);
+ memcpy(Op_val(res), callstack_buffer, sizeof(value) * callstack_len);
+ if (callstack_buffer_len > 256 && callstack_buffer_len > callstack_len * 8) {
+ caml_stat_free(callstack_buffer);
+ callstack_buffer = NULL;
+ callstack_buffer_len = 0;
+ }
+ return res;
+}
- /* This call to [caml_memprof_set] may stop sampling or change the
- callback. We have to make sure that the postponed queue is empty
- before continuing. */
- if (!caml_memprof_suspended)
- caml_raise_if_exception(caml_memprof_handle_postponed_exn());
- else
- /* But if we are currently running a callback, there is nothing
- else we can do than purging the queue. */
- purge_postponed_queue();
+/**** Data structures for tracked blocks. ****/
- if (!init) {
- int i;
- init = 1;
+struct tracked {
+ /* Memory block being sampled. This is a weak GC root. */
+ value block;
- mt_index = 624;
- mt_state[0] = 42;
- for(i = 1; i < 624; i++)
- mt_state[i] = 0x6c078965 * (mt_state[i-1] ^ (mt_state[i-1] >> 30)) + i;
+ /* Number of samples in this block. */
+ uintnat n_samples;
- caml_register_generational_global_root(&memprof_callback);
- }
+ /* The size of this block. */
+ uintnat wosize;
- lambda = l;
- if (l > 0) {
- one_log1m_lambda = l == 1 ? 0 : 1/caml_log1p(-l);
- next_mt_generate_binom = mt_generate_geom();
- }
+ /* The value returned by the previous callback for this block, or
+ the callstack if the alloc callback has not been called yet.
+ This is a strong GC root. */
+ value user_data;
- caml_memprof_renew_minor_sample();
+ /* Whether this block has been initially allocated in the minor heap. */
+ unsigned int alloc_young : 1;
- callstack_size = sz;
+ /* Whether this block comes from unmarshalling. */
+ unsigned int unmarshalled : 1;
- caml_modify_generational_global_root(&memprof_callback, Field(v, 2));
+ /* Whether this block has been promoted. Implies [alloc_young]. */
+ unsigned int promoted : 1;
- CAMLreturn(Val_unit);
-}
+ /* Whether this block has been deallocated. */
+ unsigned int deallocated : 1;
-/* Cf. Gc.Memprof.alloc_kind */
-enum ml_alloc_kind {
- Minor = Val_long(0),
- Major = Val_long(1),
- Unmarshalled = Val_long(2)
-};
+ /* Whether the allocation callback has been called. */
+ unsigned int cb_alloc_called : 1;
-/* When we call do_callback_exn, we suspend/resume sampling. In order
- to avoid a systematic unnecessary polling after each memprof
- callback, we do not call [caml_set_action_pending] when resuming.
- Therefore, any call to [do_callback_exn] has to also make sure the
- postponed queue will be handled fully at some point. */
-static value do_callback_exn(tag_t tag, uintnat wosize, uintnat occurrences,
- value callstack, enum ml_alloc_kind cb_kind)
-{
- CAMLparam1(callstack);
- CAMLlocal1(sample_info);
- value res; /* Not a root, can be an exception result. */
- CAMLassert(occurrences > 0 && !caml_memprof_suspended);
+ /* Whether the promotion callback has been called. */
+ unsigned int cb_promote_called : 1;
- caml_memprof_suspended = 1;
+ /* Whether the deallocation callback has been called. */
+ unsigned int cb_dealloc_called : 1;
- sample_info = caml_alloc_small(5, 0);
- Field(sample_info, 0) = Val_long(occurrences);
- Field(sample_info, 1) = cb_kind;
- Field(sample_info, 2) = Val_long(tag);
- Field(sample_info, 3) = Val_long(wosize);
- Field(sample_info, 4) = callstack;
+ /* Whether this entry is deleted. */
+ unsigned int deleted : 1;
- res = caml_callback_exn(memprof_callback, sample_info);
+ /* Whether a callback is currently running for this entry. */
+ unsigned int callback_running : 1;
- caml_memprof_suspended = 0;
+ /* Pointer to the [t_idx] variable in the [run_callback] frame which
+ is currently running the callback for this entry. This is needed
+ to make [run_callback] reetrant, in the case it is called
+ simultaneously by several threads. */
+ uintnat* idx_ptr;
+};
- CAMLreturn(res);
+/* During the alloc callback for a minor allocation, the block being
+ sampled is not yet allocated. Instead, we place in the block field
+ a value computed with the following macro: */
+#define Placeholder_magic 0x04200000
+#define Placeholder_offs(offset) (Val_long(offset + Placeholder_magic))
+#define Offs_placeholder(block) (Long_val(block) & 0xFFFF)
+#define Is_placeholder(block) \
+ (Is_long(block) && (Long_val(block) & ~(uintnat)0xFFFF) == Placeholder_magic)
+
+/* When an entry is deleted, its index is replaced by that integer. */
+#define Invalid_index (~(uintnat)0)
+
+
+static struct tracking_state {
+ struct tracked* entries;
+ /* The allocated capacity of the entries array */
+ uintnat alloc_len;
+ /* The number of active entries. (len <= alloc_len) */
+ uintnat len;
+ /* Before this position, the [block] and [user_data] fields point to
+ the major heap (young <= len). */
+ uintnat young;
+ /* There are no pending callbacks before this position (callback <= len). */
+ uintnat callback;
+ /* There are no blocks to be deleted before this position */
+ uintnat delete;
+} trackst;
+
+#define MIN_TRACKST_ALLOC_LEN 128
+
+
+/* Reallocate the [trackst] array if it is either too small or too
+ large.
+ Returns 1 if reallocation succeeded --[trackst.alloc_len] is at
+ least [trackst.len]--, and 0 otherwise. */
+static int realloc_trackst(void) {
+ uintnat new_alloc_len;
+ struct tracked* new_entries;
+ if (trackst.len <= trackst.alloc_len &&
+ (4*trackst.len >= trackst.alloc_len ||
+ trackst.alloc_len == MIN_TRACKST_ALLOC_LEN))
+ return 1;
+ new_alloc_len = trackst.len * 2;
+ if (new_alloc_len < MIN_TRACKST_ALLOC_LEN)
+ new_alloc_len = MIN_TRACKST_ALLOC_LEN;
+ new_entries = caml_stat_resize_noexc(trackst.entries,
+ new_alloc_len * sizeof(struct tracked));
+ if (new_entries == NULL) return 0;
+ trackst.entries = new_entries;
+ trackst.alloc_len = new_alloc_len;
+ return 1;
}
-/**** Capturing the call stack *****/
-
-/* This function is called for postponed blocks, so it guarantees
- that the GC is not called. */
-static value capture_callstack_postponed(void)
+Caml_inline uintnat new_tracked(uintnat n_samples, uintnat wosize,
+ int is_unmarshalled, int is_young,
+ value block, value user_data)
{
- value res;
- uintnat wosize = caml_current_callstack_size(callstack_size);
- /* We do not use [caml_alloc] to make sure the GC will not get called. */
- if (wosize == 0) return Atom (0);
- res = caml_alloc_shr_no_track_noexc(wosize, 0);
- if (res != 0) caml_current_callstack_write(res);
- return res;
+ struct tracked *t;
+ trackst.len++;
+ if (!realloc_trackst()) {
+ trackst.len--;
+ return Invalid_index;
+ }
+ t = &trackst.entries[trackst.len - 1];
+ t->block = block;
+ t->n_samples = n_samples;
+ t->wosize = wosize;
+ t->user_data = user_data;
+ t->idx_ptr = NULL;
+ t->alloc_young = is_young;
+ t->unmarshalled = is_unmarshalled;
+ t->promoted = 0;
+ t->deallocated = 0;
+ t->cb_alloc_called = t->cb_promote_called = t->cb_dealloc_called = 0;
+ t->deleted = 0;
+ t->callback_running = 0;
+ return trackst.len - 1;
}
-static value capture_callstack(void)
+static void mark_deleted(uintnat t_idx)
{
+ struct tracked* t = &trackst.entries[t_idx];
+ t->deleted = 1;
+ t->user_data = Val_unit;
+ t->block = Val_unit;
+ if (t_idx < trackst.delete) trackst.delete = t_idx;
+ CAMLassert(t->idx_ptr == NULL);
+}
+
+/* The return value is an exception or [Val_unit] iff [*t_idx] is set to
+ [Invalid_index]. In this case, the entry is deleted.
+ Otherwise, the return value is a [Some(...)] block. */
+Caml_inline value run_callback_exn(uintnat *t_idx, value cb, value param) {
+ struct tracked* t = &trackst.entries[*t_idx];
value res;
- uintnat wosize = caml_current_callstack_size(callstack_size);
- CAMLassert(!caml_memprof_suspended);
- caml_memprof_suspended = 1; /* => no samples in the call stack. */
- res = caml_alloc(wosize, 0);
- caml_memprof_suspended = 0;
- caml_current_callstack_write(res);
+ CAMLassert(!t->callback_running && t->idx_ptr == NULL);
+ CAMLassert(lambda > 0.);
+
+ callback_running = t->callback_running = 1;
+ t->idx_ptr = t_idx;
+ res = caml_callback_exn(cb, param);
+ callback_running = 0;
+ /* The call above can modify [*t_idx] and thus invalidate [t]. */
+ if (*t_idx == Invalid_index) {
+ /* Make sure this entry has not been removed by [caml_memprof_set] */
+ return Val_unit;
+ }
+ t = &trackst.entries[*t_idx];
+ t->idx_ptr = NULL;
+ t->callback_running = 0;
+ if (Is_exception_result(res) || res == Val_unit) {
+ /* Callback raised an exception or returned None or (), discard
+ this entry. */
+ mark_deleted(*t_idx);
+ *t_idx = Invalid_index;
+ }
return res;
}
-/**** Handling postponed sampled blocks. ****/
-/* When allocating in from C code, we cannot call the callback,
- because the [caml_alloc_***] are guaranteed not to do so. These
- functions make it possible to register a sampled block in a
- todo-list so that the callback call is performed when possible. */
-/* Note: the shorter the delay is, the better, because the block is
- linked to a root during the delay, so that the reachability
- properties of the sampled block are artificially modified. */
-
-#define POSTPONED_DEFAULT_QUEUE_SIZE 128
-static struct postponed_block {
- value block;
- value callstack;
- uintnat occurrences;
- enum ml_alloc_kind kind;
-} default_postponed_queue[POSTPONED_DEFAULT_QUEUE_SIZE],
- *postponed_queue = default_postponed_queue,
- *postponed_queue_end = default_postponed_queue + POSTPONED_DEFAULT_QUEUE_SIZE,
- *postponed_tl = default_postponed_queue, /* Pointer to next pop */
- *postponed_hd = default_postponed_queue; /* Pointer to next push */
-
-static struct postponed_block* postponed_next(struct postponed_block* p)
+/* Run all the needed callbacks for a given entry.
+ In case of a thread context switch during a callback, this can be
+ called in a reetrant way.
+ If [*t_idx] equals [trackst.callback], then this function
+ increments [trackst.callback].
+ The index of the entry may change. It is set to [Invalid_index] if
+ the entry is discarded.
+ Returns:
+ - An exception result if the callback raised an exception
+ - Val_long(0) == Val_unit == None otherwise
+ */
+static value handle_entry_callbacks_exn(uintnat* t_idx)
{
- p++;
- if (p == postponed_queue_end) return postponed_queue;
- else return p;
-}
+ value sample_info, res, user_data; /* No need to make these roots */
+ struct tracked* t = &trackst.entries[*t_idx];
+ if (*t_idx == trackst.callback) trackst.callback++;
+
+ if (t->deleted || t->callback_running) return Val_unit;
+
+ if (!t->cb_alloc_called) {
+ t->cb_alloc_called = 1;
+ CAMLassert(Is_block(t->block)
+ || Is_placeholder(t->block)
+ || t->deallocated);
+ sample_info = caml_alloc_small(4, 0);
+ Field(sample_info, 0) = Val_long(t->n_samples);
+ Field(sample_info, 1) = Val_long(t->wosize);
+ Field(sample_info, 2) = Val_long(t->unmarshalled);
+ Field(sample_info, 3) = t->user_data;
+ t->user_data = Val_unit;
+ res = run_callback_exn(t_idx,
+ t->alloc_young ? Alloc_minor(tracker) : Alloc_major(tracker),
+ sample_info);
+ if (*t_idx == Invalid_index)
+ return res;
+ CAMLassert(!Is_exception_result(res) && Is_block(res) && Tag_val(res) == 0
+ && Wosize_val(res) == 1);
+ t = &trackst.entries[*t_idx];
+ t->user_data = Field(res, 0);
+ if (Is_block(t->user_data) && Is_young(t->user_data) &&
+ *t_idx < trackst.young)
+ trackst.young = *t_idx;
+ }
-static void purge_postponed_queue(void)
-{
- if (postponed_queue != default_postponed_queue) {
- caml_stat_free(postponed_queue);
- postponed_queue = default_postponed_queue;
- postponed_queue_end = postponed_queue + POSTPONED_DEFAULT_QUEUE_SIZE;
+ if (t->promoted && !t->cb_promote_called) {
+ t->cb_promote_called = 1;
+ user_data = t->user_data;
+ t->user_data = Val_unit;
+ res = run_callback_exn(t_idx, Promote(tracker), user_data);
+ if (*t_idx == Invalid_index)
+ return res;
+ CAMLassert(!Is_exception_result(res) && Is_block(res) && Tag_val(res) == 0
+ && Wosize_val(res) == 1);
+ t = &trackst.entries[*t_idx];
+ t->user_data = Field(res, 0);
+ if (Is_block(t->user_data) && Is_young(t->user_data) &&
+ *t_idx < trackst.young)
+ trackst.young = *t_idx;
+ }
+
+ if (t->deallocated && !t->cb_dealloc_called) {
+ value cb = (t->promoted || !t->alloc_young) ?
+ Dealloc_major(tracker) : Dealloc_minor(tracker);
+ t->cb_dealloc_called = 1;
+ user_data = t->user_data;
+ t->user_data = Val_unit;
+ res = run_callback_exn(t_idx, cb, user_data);
+ /* [t] is invalid, but we do no longer use it. */
+ CAMLassert(*t_idx == Invalid_index);
+ CAMLassert(Is_exception_result(res) || res == Val_unit);
+ return res;
}
- postponed_hd = postponed_tl = postponed_queue;
+
+ return Val_unit;
}
-/* This function does not call the GC. This is important since it is
- called when allocating a block using [caml_alloc_shr]: The new
- block is allocated, but not yet initialized, so that the heap
- invariants are broken. */
-static void register_postponed_callback(value block, uintnat occurrences,
- enum ml_alloc_kind kind,
- value* callstack)
+/* Remove any deleted entries, updating callback and young */
+static void flush_deleted(void)
{
- struct postponed_block* new_hd;
- if (occurrences == 0) return;
- if (*callstack == 0) *callstack = capture_callstack_postponed();
- if (*callstack == 0) return; /* OOM */
-
- new_hd = postponed_next(postponed_hd);
- if (new_hd == postponed_tl) {
- /* Queue is full, reallocate it. (We always leave one free slot in
- order to be able to distinguish the 100% full and the empty
- states). */
- uintnat sz = 2 * (postponed_queue_end - postponed_queue);
- struct postponed_block* new_queue =
- caml_stat_alloc_noexc(sz * sizeof(struct postponed_block));
- if (new_queue == NULL) return;
- new_hd = new_queue;
- while (postponed_tl != postponed_hd) {
- *new_hd = *postponed_tl;
- new_hd++;
- postponed_tl = postponed_next(postponed_tl);
+ uintnat i = trackst.delete, j = i;
+ while (i < trackst.len) {
+ if (!trackst.entries[i].deleted) {
+ if (trackst.entries[i].idx_ptr != NULL)
+ *trackst.entries[i].idx_ptr = j;
+ trackst.entries[j] = trackst.entries[i];
+ j++;
}
- if (postponed_queue != default_postponed_queue)
- caml_stat_free(postponed_queue);
- postponed_tl = postponed_queue = new_queue;
- postponed_hd = new_hd;
- postponed_queue_end = postponed_queue + sz;
- new_hd++;
+ i++;
+ if (trackst.young == i) trackst.young = j;
+ if (trackst.callback == i) trackst.callback = j;
}
+ trackst.delete = trackst.len = j;
+ CAMLassert(trackst.callback <= trackst.len);
+ CAMLassert(trackst.young <= trackst.len);
+ realloc_trackst();
+}
- postponed_hd->block = block;
- postponed_hd->callstack = *callstack;
- postponed_hd->occurrences = occurrences;
- postponed_hd->kind = kind;
- postponed_hd = new_hd;
-
- if (!caml_memprof_suspended) caml_set_action_pending();
+static void check_action_pending(void) {
+ if (!caml_memprof_suspended && trackst.callback < trackst.len)
+ caml_set_action_pending();
}
+/* In case of a thread context switch during a callback, this can be
+ called in a reetrant way. */
value caml_memprof_handle_postponed_exn(void)
{
- CAMLparam0();
- CAMLlocal1(block);
- value ephe;
-
- if (caml_memprof_suspended)
- CAMLreturn(Val_unit);
-
- while (postponed_tl != postponed_hd) {
- struct postponed_block pb = *postponed_tl;
- block = pb.block; /* pb.block is not a root! */
- postponed_tl = postponed_next(postponed_tl);
- if (postponed_tl == postponed_hd) purge_postponed_queue();
-
- /* If using threads, this call can trigger reentrant calls to
- [caml_memprof_handle_postponed] even though we set
- [caml_memprof_suspended]. */
- ephe = do_callback_exn(Tag_val(block), Wosize_val(block),
- pb.occurrences, pb.callstack, pb.kind);
+ value res = Val_unit;
+ if (caml_memprof_suspended) return res;
+ caml_memprof_suspended = 1;
+ while (trackst.callback < trackst.len) {
+ uintnat i = trackst.callback;
+ res = handle_entry_callbacks_exn(&i);
+ if (Is_exception_result(res)) break;
+ }
+ caml_memprof_suspended = 0;
+ check_action_pending(); /* Needed in case of an exception */
+ flush_deleted();
+ return res;
+}
- if (Is_exception_result(ephe)) CAMLreturn(ephe);
+void caml_memprof_oldify_young_roots(void)
+{
+ uintnat i;
+ /* This loop should always have a small number of iteration (when
+ compared to the size of the minor heap), because the young
+ pointer should always be close to the end of the array. Indeed,
+ it is only moved back when returning from a callback triggered by
+ allocation or promotion, which can only happen for blocks
+ allocated recently, which are close to the end of the trackst
+ array. */
+ for (i = trackst.young; i < trackst.len; i++)
+ caml_oldify_one(trackst.entries[i].user_data,
+ &trackst.entries[i].user_data);
+}
- if (Is_block(ephe)) caml_ephemeron_set_key(Field(ephe, 0), 0, block);
+void caml_memprof_minor_update(void)
+{
+ uintnat i;
+ /* See comment in [caml_memprof_oldify_young_roots] for the number
+ of iterations of this loop. */
+ for (i = trackst.young; i < trackst.len; i++) {
+ struct tracked *t = &trackst.entries[i];
+ CAMLassert(Is_block(t->block) || t->deleted || t->deallocated ||
+ Is_placeholder(t->block));
+ if (Is_block(t->block) && Is_young(t->block)) {
+ if (Hd_val(t->block) == 0) {
+ /* Block has been promoted */
+ t->block = Field(t->block, 0);
+ t->promoted = 1;
+ } else {
+ /* Block is dead */
+ CAMLassert_young_header(Hd_val(t->block));
+ t->block = Val_unit;
+ t->deallocated = 1;
+ }
+ }
}
+ if (trackst.callback > trackst.young) {
+ trackst.callback = trackst.young;
+ check_action_pending();
+ }
+ trackst.young = trackst.len;
+}
- CAMLreturn(Val_unit);
+void caml_memprof_do_roots(scanning_action f)
+{
+ uintnat i;
+ for (i = 0; i < trackst.len; i++)
+ f(trackst.entries[i].user_data, &trackst.entries[i].user_data);
}
-/* We don't expect these roots to live long. No need to have a special
- case for young roots. */
-void caml_memprof_scan_roots(scanning_action f) {
- struct postponed_block* p;
- for(p = postponed_tl; p != postponed_hd; p = postponed_next(p)) {
- f(p->block, &p->block);
- f(p->callstack, &p->callstack);
+void caml_memprof_update_clean_phase(void)
+{
+ uintnat i;
+ for (i = 0; i < trackst.len; i++) {
+ struct tracked *t = &trackst.entries[i];
+ if (Is_block(t->block) && !Is_young(t->block)) {
+ CAMLassert(Is_in_heap(t->block));
+ CAMLassert(!t->alloc_young || t->promoted);
+ if (Is_white_val(t->block)) {
+ t->block = Val_unit;
+ t->deallocated = 1;
+ }
+ }
}
+ trackst.callback = 0;
+ check_action_pending();
+}
+
+void caml_memprof_invert_tracked(void)
+{
+ uintnat i;
+ for (i = 0; i < trackst.len; i++)
+ caml_invert_root(trackst.entries[i].block, &trackst.entries[i].block);
}
/**** Sampling procedures ****/
void caml_memprof_track_alloc_shr(value block)
{
+ uintnat n_samples;
value callstack = 0;
CAMLassert(Is_in_heap(block));
+
/* This test also makes sure memprof is initialized. */
if (lambda == 0 || caml_memprof_suspended) return;
- register_postponed_callback(
- block, mt_generate_binom(Whsize_val(block)), Major, &callstack);
+
+ n_samples = mt_generate_binom(Whsize_val(block));
+ if (n_samples == 0) return;
+
+ callstack = capture_callstack_postponed();
+ if (callstack == 0) return;
+
+ new_tracked(n_samples, Wosize_val(block), 0, 0, block, callstack);
+ check_action_pending();
}
/* Shifts the next sample in the minor heap by [n] words. Essentially,
caml_memprof_young_trigger = Caml_state->young_alloc_start;
else {
uintnat geom = mt_generate_geom();
- if(Caml_state->young_ptr - Caml_state->young_alloc_start < geom)
+ if (Caml_state->young_ptr - Caml_state->young_alloc_start < geom)
/* No trigger in the current minor heap. */
caml_memprof_young_trigger = Caml_state->young_alloc_start;
caml_memprof_young_trigger = Caml_state->young_ptr - (geom - 1);
/* Called when exceeding the threshold for the next sample in the
minor heap, from the C code (the handling is different when called
from natively compiled OCaml code). */
-void caml_memprof_track_young(tag_t tag, uintnat wosize, int from_caml)
+void caml_memprof_track_young(uintnat wosize, int from_caml,
+ int nallocs, unsigned char* encoded_alloc_lens)
{
- CAMLparam0();
- CAMLlocal2(ephe, callstack);
uintnat whsize = Whsize_wosize(wosize);
- uintnat occurrences;
+ value callstack, res = Val_unit;
+ int alloc_idx = 0, i, allocs_sampled = 0, has_delete = 0;
+ intnat alloc_ofs, trigger_ofs;
+ /* usually, only one allocation is sampled, even when the block contains
+ multiple combined allocations. So, we delay allocating the full
+ sampled_allocs array until we discover we actually need two entries */
+ uintnat first_idx, *idx_tab = &first_idx;
+ double saved_lambda = lambda;
if (caml_memprof_suspended) {
caml_memprof_renew_minor_sample();
- CAMLreturn0;
+ return;
}
/* If [lambda == 0], then [caml_memprof_young_trigger] should be
caml_memprof_young_trigger], which is contradictory. */
CAMLassert(lambda > 0);
- occurrences =
- mt_generate_binom(caml_memprof_young_trigger - 1
- - Caml_state->young_ptr) + 1;
-
if (!from_caml) {
- value callstack = 0;
- register_postponed_callback(Val_hp(Caml_state->young_ptr), occurrences,
- Minor, &callstack);
+ unsigned n_samples = 1 +
+ mt_generate_binom(caml_memprof_young_trigger - 1 - Caml_state->young_ptr);
+ CAMLassert(encoded_alloc_lens == NULL); /* No Comballoc in C! */
caml_memprof_renew_minor_sample();
- CAMLreturn0;
+
+ callstack = capture_callstack_postponed();
+ if (callstack == 0) return;
+
+ new_tracked(n_samples, wosize,
+ 0, 1, Val_hp(Caml_state->young_ptr), callstack);
+ check_action_pending();
+ return;
}
- /* We need to call the callback for this sampled block. Since the
+ /* We need to call the callbacks for this sampled block. Since each
callback can potentially allocate, the sampled block will *not*
be the one pointed to by [caml_memprof_young_trigger]. Instead,
we remember that we need to sample the next allocated word,
call the callback and use as a sample the block which will be
allocated right after the callback. */
- /* Restore the minor heap in a valid state for calling the callback.
+ CAMLassert(Caml_state->young_ptr < caml_memprof_young_trigger &&
+ caml_memprof_young_trigger <= Caml_state->young_ptr + whsize);
+ trigger_ofs = caml_memprof_young_trigger - Caml_state->young_ptr;
+ alloc_ofs = whsize;
+
+ /* Restore the minor heap in a valid state for calling the callbacks.
We should not call the GC before these two instructions. */
Caml_state->young_ptr += whsize;
caml_memprof_renew_minor_sample();
+ caml_memprof_suspended = 1;
- /* Empty the queue to make sure callbacks are called in the right
- order. */
- caml_raise_if_exception(caml_memprof_handle_postponed_exn());
+ /* Perform the sampling of the block in the set of Comballoc'd
+ blocks, insert them in the entries array, and run the
+ callbacks. */
+ for (alloc_idx = nallocs - 1; alloc_idx >= 0; alloc_idx--) {
+ unsigned alloc_wosz = encoded_alloc_lens == NULL ? wosize :
+ Wosize_encoded_alloc_len(encoded_alloc_lens[alloc_idx]);
+ unsigned n_samples = 0;
+ alloc_ofs -= Whsize_wosize(alloc_wosz);
+ while (alloc_ofs < trigger_ofs) {
+ n_samples++;
+ trigger_ofs -= mt_generate_geom();
+ }
+ if (n_samples > 0) {
+ uintnat *idx_ptr, t_idx;
+
+ callstack = capture_callstack(alloc_idx);
+ t_idx = new_tracked(n_samples, alloc_wosz,
+ 0, 1, Placeholder_offs(alloc_ofs), callstack);
+ if (t_idx == Invalid_index) continue;
+ res = handle_entry_callbacks_exn(&t_idx);
+ if (t_idx == Invalid_index) {
+ has_delete = 1;
+ if (saved_lambda != lambda) {
+ /* [lambda] changed during the callback. We need to refresh
+ [trigger_ofs]. */
+ saved_lambda = lambda;
+ trigger_ofs = lambda == 0. ? 0 : alloc_ofs - (mt_generate_geom() - 1);
+ }
+ }
+ if (Is_exception_result(res)) break;
+ if (t_idx == Invalid_index) continue;
+
+ if (allocs_sampled == 1) {
+ /* Found a second sampled allocation! Allocate a buffer for them */
+ idx_tab = caml_stat_alloc_noexc(sizeof(uintnat) * nallocs);
+ if (idx_tab == NULL) {
+ alloc_ofs = 0;
+ idx_tab = &first_idx;
+ break;
+ }
+ idx_tab[0] = first_idx;
+ if (idx_tab[0] != Invalid_index)
+ trackst.entries[idx_tab[0]].idx_ptr = &idx_tab[0];
+ }
+
+ /* Usually, trackst.entries[...].idx_ptr is owned by the thread
+ running a callback for the entry, if any. Here, we take ownership
+ of idx_ptr until the end of the function.
+
+ This does not conflict with the usual use of idx_ptr because no
+ callbacks can run on this entry until the end of the function:
+ the allocation callback has already run and the other callbacks
+ do not run on Placeholder values */
+ idx_ptr = &idx_tab[allocs_sampled];
+ *idx_ptr = t_idx;
+ trackst.entries[*idx_ptr].idx_ptr = idx_ptr;
+ allocs_sampled++;
+ }
+ }
- callstack = capture_callstack();
- ephe = caml_raise_if_exception(do_callback_exn(tag, wosize, occurrences,
- callstack, Minor));
+ CAMLassert(alloc_ofs == 0 || Is_exception_result(res));
+ CAMLassert(allocs_sampled <= nallocs);
+ caml_memprof_suspended = 0;
+ check_action_pending();
+ /* We need to call [check_action_pending] since we
+ reset [caml_memprof_suspended] to 0 (a GC collection may have
+ triggered some new callback).
+
+ We need to make sure that the action pending flag is not set
+ systematically, which is to be expected, since [new_tracked]
+ created a new block without updating
+ [trackst.callback]. Fortunately, [handle_entry_callback_exn]
+ increments [trackst.callback] if it is equal to [t_idx]. */
+
+ /* This condition happens either in the case of an exception or if
+ one of the callbacks returned [None]. If these cases happen
+ frequently, then we need to call [flush_deleted] somewhere to
+ prevent a leak. */
+ if (has_delete)
+ flush_deleted();
+
+ if (Is_exception_result(res)) {
+ for (i = 0; i < allocs_sampled; i++)
+ if (idx_tab[i] != Invalid_index) {
+ struct tracked* t = &trackst.entries[idx_tab[i]];
+ /* The allocations are cancelled because of the exception,
+ but this callback has already been called. We simulate a
+ deallocation. */
+ t->block = Val_unit;
+ t->deallocated = 1;
+ if (trackst.callback > idx_tab[i]) {
+ trackst.callback = idx_tab[i];
+ check_action_pending();
+ }
+ }
+ if (idx_tab != &first_idx) caml_stat_free(idx_tab);
+ caml_raise(Extract_exception(res));
+ }
/* We can now restore the minor heap in the state needed by
[Alloc_small_aux]. */
if (Caml_state->young_ptr - whsize < Caml_state->young_trigger) {
- CAML_INSTR_INT ("force_minor/memprof@", 1);
+ CAML_EV_COUNTER(EV_C_FORCE_MINOR_MEMPROF, 1);
caml_gc_dispatch();
}
- /* Re-allocate the block in the minor heap. We should not call the
+ /* Re-allocate the blocks in the minor heap. We should not call the
GC after this. */
Caml_state->young_ptr -= whsize;
/* Make sure this block is not going to be sampled again. */
shift_sample(whsize);
- /* Write the ephemeron if not [None]. */
- if (Is_block(ephe)) {
- /* Subtlety: we are actually writing the ephemeron with an invalid
- (uninitialized) block. This is correct for two reasons:
- - The logic of [caml_ephemeron_set_key] never inspects the content of
- the block. In only checks that the block is young.
- - The allocation and initialization happens right after returning
- from [caml_memprof_track_young]. */
- caml_ephemeron_set_key(Field(ephe, 0), 0, Val_hp(Caml_state->young_ptr));
+ for (i = 0; i < allocs_sampled; i++) {
+ if (idx_tab[i] != Invalid_index) {
+ /* If the execution of the callback has succeeded, then we start the
+ tracking of this block..
+
+ Subtlety: we are actually writing [t->block] with an invalid
+ (uninitialized) block. This is correct because the allocation
+ and initialization happens right after returning from
+ [caml_memprof_track_young]. */
+ struct tracked *t = &trackst.entries[idx_tab[i]];
+ t->block = Val_hp(Caml_state->young_ptr + Offs_placeholder(t->block));
+ t->idx_ptr = NULL;
+ CAMLassert(t->cb_alloc_called);
+ if (idx_tab[i] < trackst.young) trackst.young = idx_tab[i];
+ }
}
+ if (idx_tab != &first_idx) caml_stat_free(idx_tab);
/* /!\ Since the heap is in an invalid state before initialization,
very little heap operations are allowed until then. */
- CAMLreturn0;
+ return;
}
void caml_memprof_track_interned(header_t* block, header_t* blockend) {
header_t *p;
value callstack = 0;
+ int is_young = Is_young(Val_hp(block));
- if(lambda == 0 || caml_memprof_suspended)
+ if (lambda == 0 || caml_memprof_suspended)
return;
- /* We have to select the sampled blocks before sampling them,
- because sampling may trigger GC, and then blocks can escape from
- [block, blockend[. So we use the postponing machinery for
- selecting blocks. [intern.c] will call [check_urgent_gc] which
- will call [caml_memprof_handle_postponed] in turn. */
p = block;
- while(1) {
+ while (1) {
uintnat next_sample = mt_generate_geom();
header_t *next_sample_p, *next_p;
- if(next_sample > blockend - p)
+ if (next_sample > blockend - p)
break;
/* [next_sample_p] is the block *following* the next sampled
block! */
next_sample_p = p + next_sample;
- while(1) {
+ while (1) {
next_p = p + Whsize_hp(p);
- if(next_p >= next_sample_p) break;
+ if (next_p >= next_sample_p) break;
p = next_p;
}
- register_postponed_callback(
- Val_hp(p), mt_generate_binom(next_p - next_sample_p) + 1,
- Unmarshalled, &callstack);
-
+ if (callstack == 0) callstack = capture_callstack_postponed();
+ if (callstack == 0) break; /* OOM */
+ new_tracked(mt_generate_binom(next_p - next_sample_p) + 1,
+ Wosize_hp(p), 1, is_young, Val_hp(p), callstack);
p = next_p;
}
+ check_action_pending();
+}
+
+/**** Interface with the OCaml code. ****/
+
+static void caml_memprof_init(void) {
+ uintnat i;
+
+ init = 1;
+
+ mt_index = MT_STATE_SIZE;
+ mt_state[0] = 42;
+ for (i = 1; i < MT_STATE_SIZE; i++)
+ mt_state[i] = 0x6c078965 * (mt_state[i-1] ^ (mt_state[i-1] >> 30)) + i;
+}
+
+void caml_memprof_shutdown(void) {
+ init = 0;
+ started = 0;
+ lambda = 0.;
+ caml_memprof_suspended = 0;
+ trackst.len = 0;
+ trackst.callback = trackst.young = trackst.delete = 0;
+ caml_stat_free(trackst.entries);
+ trackst.entries = NULL;
+ trackst.alloc_len = 0;
+ caml_stat_free(callstack_buffer);
+ callstack_buffer = NULL;
+ callstack_buffer_len = 0;
+}
+
+CAMLprim value caml_memprof_start(value lv, value szv, value tracker_param)
+{
+ CAMLparam3(lv, szv, tracker_param);
+
+ double l = Double_val(lv);
+ intnat sz = Long_val(szv);
+
+ if (started) caml_failwith("Gc.Memprof.start: already started.");
+
+ if (sz < 0 || !(l >= 0.) || l > 1.) /* Checks that [l] is not NAN. */
+ caml_invalid_argument("Gc.Memprof.start");
+
+ if (!init) caml_memprof_init();
+
+ lambda = l;
+ if (l > 0) {
+ one_log1m_lambda = l == 1 ? 0 : 1/caml_log1p(-l);
+ next_mt_generate_geom = mt_generate_geom();
+ }
+
+ caml_memprof_renew_minor_sample();
+
+ callstack_size = sz;
+ started = 1;
+
+ tracker = tracker_param;
+ caml_register_generational_global_root(&tracker);
+
+ CAMLreturn(Val_unit);
+}
+
+CAMLprim value caml_memprof_stop(value unit)
+{
+ uintnat i;
+
+ if (!started) caml_failwith("Gc.Memprof.stop: not started.");
+
+ /* This call to [caml_memprof_stop] will discard all the previously
+ tracked blocks. We try one last time to call the postponed
+ callbacks. */
+ caml_raise_if_exception(caml_memprof_handle_postponed_exn());
+
+ /* Discard the tracked blocks. */
+ for (i = 0; i < trackst.len; i++)
+ if (trackst.entries[i].idx_ptr != NULL)
+ *trackst.entries[i].idx_ptr = Invalid_index;
+ trackst.len = 0;
+ trackst.callback = trackst.young = trackst.delete = 0;
+ caml_stat_free(trackst.entries);
+ trackst.entries = NULL;
+ trackst.alloc_len = 0;
+
+ lambda = 0;
+ caml_memprof_renew_minor_sample();
+ started = 0;
+
+ caml_remove_generational_global_root(&tracker);
+
+ caml_stat_free(callstack_buffer);
+ callstack_buffer = NULL;
+ callstack_buffer_len = 0;
+
+ return Val_unit;
+}
+
+/**** Interface with systhread. ****/
+
+void caml_memprof_init_th_ctx(struct caml_memprof_th_ctx* ctx) {
+ ctx->suspended = 0;
+ ctx->callback_running = 0;
+}
+
+void caml_memprof_stop_th_ctx(struct caml_memprof_th_ctx* ctx) {
+ /* Make sure that no memprof callback is being executed in this
+ thread. If so, memprof data structures may have pointers to the
+ thread's stack. */
+ if(ctx->callback_running)
+ caml_fatal_error("Thread.exit called from a memprof callback.");
+}
+
+void caml_memprof_save_th_ctx(struct caml_memprof_th_ctx* ctx) {
+ ctx->suspended = caml_memprof_suspended;
+ ctx->callback_running = callback_running;
+}
+
+void caml_memprof_restore_th_ctx(const struct caml_memprof_th_ctx* ctx) {
+ caml_memprof_suspended = ctx->suspended;
+ callback_running = ctx->callback_running;
+ check_action_pending();
}
#include "caml/signals.h"
#include "caml/weak.h"
#include "caml/memprof.h"
+#ifdef WITH_SPACETIME
+#include "caml/spacetime.h"
+#endif
+#include "caml/eventlog.h"
/* Pointers into the minor heap.
[Caml_state->young_base]
CAMLassert (bsz % Page_size == 0);
CAMLassert (bsz % sizeof (value) == 0);
if (Caml_state->young_ptr != Caml_state->young_alloc_end){
- CAML_INSTR_INT ("force_minor/set_minor_heap_size@", 1);
+ CAML_EV_COUNTER (EV_C_FORCE_MINOR_SET_MINOR_HEAP_SIZE, 1);
Caml_state->requested_minor_gc = 0;
Caml_state->young_trigger = Caml_state->young_alloc_mid;
caml_update_young_limit();
if (hd == 0){ /* If already forwarded */
*p = Field (v, 0); /* then forward pointer is first field. */
}else{
+ CAMLassert_young_header(hd);
tag = Tag_hd (hd);
if (tag < Infix_tag){
value field0;
}
/* Test if the ephemeron is alive, everything outside minor heap is alive */
-static inline int ephe_check_alive_data(struct caml_ephe_ref_elt *re){
+Caml_inline int ephe_check_alive_data(struct caml_ephe_ref_elt *re){
mlsize_t i;
value child;
for (i = CAML_EPHE_FIRST_KEY; i < Wosize_val(re->ephe); i++){
struct caml_ephe_ref_elt *re;
if (Caml_state->young_ptr != Caml_state->young_alloc_end){
+ CAMLassert_young_header(*(header_t*)Caml_state->young_ptr);
if (caml_minor_gc_begin_hook != NULL) (*caml_minor_gc_begin_hook) ();
- CAML_INSTR_SETUP (tmr, "minor");
prev_alloc_words = caml_allocated_words;
Caml_state->in_minor_collection = 1;
caml_gc_message (0x02, "<");
+ CAML_EV_BEGIN(EV_MINOR_LOCAL_ROOTS);
caml_oldify_local_roots();
- CAML_INSTR_TIME (tmr, "minor/local_roots");
+ CAML_EV_END(EV_MINOR_LOCAL_ROOTS);
+ CAML_EV_BEGIN(EV_MINOR_REF_TABLES);
for (r = Caml_state->ref_table->base;
r < Caml_state->ref_table->ptr; r++) {
caml_oldify_one (**r, *r);
}
- CAML_INSTR_TIME (tmr, "minor/ref_table");
+ CAML_EV_END(EV_MINOR_REF_TABLES);
+ CAML_EV_BEGIN(EV_MINOR_COPY);
caml_oldify_mopup ();
- CAML_INSTR_TIME (tmr, "minor/copy");
+ CAML_EV_END(EV_MINOR_COPY);
/* Update the ephemerons */
for (re = Caml_state->ephe_ref_table->base;
re < Caml_state->ephe_ref_table->ptr; re++){
}
}
/* Update the OCaml finalise_last values */
+ CAML_EV_BEGIN(EV_MINOR_UPDATE_WEAK);
caml_final_update_minor_roots();
+ /* Trigger memprofs callbacks for blocks in the minor heap. */
+ caml_memprof_minor_update();
/* Run custom block finalisation of dead minor values */
for (elt = Caml_state->custom_table->base;
elt < Caml_state->custom_table->ptr; elt++){
if (final_fun != NULL) final_fun(v);
}
}
- CAML_INSTR_TIME (tmr, "minor/update_weak");
+ CAML_EV_END(EV_MINOR_UPDATE_WEAK);
+ CAML_EV_BEGIN(EV_MINOR_FINALIZED);
Caml_state->stat_minor_words +=
Caml_state->young_alloc_end - Caml_state->young_ptr;
caml_gc_clock +=
caml_gc_message (0x02, ">");
Caml_state->in_minor_collection = 0;
caml_final_empty_young ();
- CAML_INSTR_TIME (tmr, "minor/finalized");
+ CAML_EV_END(EV_MINOR_FINALIZED);
Caml_state->stat_promoted_words += caml_allocated_words - prev_alloc_words;
- CAML_INSTR_INT ("minor/promoted#", caml_allocated_words - prev_alloc_words);
+ CAML_EV_COUNTER (EV_C_MINOR_PROMOTED,
+ caml_allocated_words - prev_alloc_words);
++ Caml_state->stat_minor_collections;
caml_memprof_renew_minor_sample();
if (caml_minor_gc_end_hook != NULL) (*caml_minor_gc_end_hook) ();
#ifdef CAML_INSTR
extern uintnat caml_instr_alloc_jump;
-#endif
+#endif /*CAML_INSTR*/
/* Do a minor collection or a slice of major collection, call finalisation
functions, etc.
CAMLexport void caml_gc_dispatch (void)
{
value *trigger = Caml_state->young_trigger; /* save old value of trigger */
-#ifdef CAML_INSTR
- CAML_INSTR_SETUP(tmr, "dispatch");
- CAML_INSTR_TIME (tmr, "overhead");
- CAML_INSTR_INT ("alloc/jump#", caml_instr_alloc_jump);
- caml_instr_alloc_jump = 0;
-#endif
+
+ CAML_EVENTLOG_DO({
+ CAML_EV_COUNTER(EV_C_ALLOC_JUMP, caml_instr_alloc_jump);
+ caml_instr_alloc_jump = 0;
+ });
if (trigger == Caml_state->young_alloc_start
|| Caml_state->requested_minor_gc) {
/* The minor heap is full, we must do a minor collection. */
/* reset the pointers first because the end hooks might allocate */
+ CAML_EV_BEGIN(EV_MINOR);
Caml_state->requested_minor_gc = 0;
Caml_state->young_trigger = Caml_state->young_alloc_mid;
caml_update_young_limit();
caml_empty_minor_heap ();
/* The minor heap is empty, we can start a major collection. */
- if (caml_gc_phase == Phase_idle) caml_major_collection_slice (-1);
- CAML_INSTR_TIME (tmr, "dispatch/minor");
+ CAML_EV_END(EV_MINOR);
+ if (caml_gc_phase == Phase_idle)
+ {
+ CAML_EV_BEGIN(EV_MAJOR);
+ caml_major_collection_slice (-1);
+ CAML_EV_END(EV_MAJOR);
+ }
}
if (trigger != Caml_state->young_alloc_start
|| Caml_state->requested_major_slice) {
Caml_state->requested_major_slice = 0;
Caml_state->young_trigger = Caml_state->young_alloc_start;
caml_update_young_limit();
+ CAML_EV_BEGIN(EV_MAJOR);
caml_major_collection_slice (-1);
- CAML_INSTR_TIME (tmr, "dispatch/major");
+ CAML_EV_END(EV_MAJOR);
}
}
-/* Called by [Alloc_small] when [Caml_state->young_ptr] reaches
+/* Called by young allocations when [Caml_state->young_ptr] reaches
[Caml_state->young_limit]. We may have to either call memprof or
the gc. */
-void caml_alloc_small_dispatch (tag_t tag, intnat wosize, int flags)
+void caml_alloc_small_dispatch (intnat wosize, int flags,
+ int nallocs, unsigned char* encoded_alloc_lens)
{
intnat whsize = Whsize_wosize (wosize);
/* If not, then empty the minor heap, and check again for async
callbacks. */
- CAML_INSTR_INT ("force_minor/alloc_small@", 1);
+ CAML_EV_COUNTER (EV_C_FORCE_MINOR_ALLOC_SMALL, 1);
caml_gc_dispatch ();
+#if defined(NATIVE_CODE) && defined(WITH_SPACETIME)
+ if (caml_young_ptr == caml_young_alloc_end) {
+ caml_spacetime_automatic_snapshot();
+ }
+#endif
}
/* Re-do the allocation: we now have enough space in the minor heap. */
/* Check if the allocated block has been sampled by memprof. */
if(Caml_state->young_ptr < caml_memprof_young_trigger){
if(flags & CAML_DO_TRACK) {
- caml_memprof_track_young(tag, wosize, flags & CAML_FROM_CAML);
+ caml_memprof_track_young(wosize, flags & CAML_FROM_CAML,
+ nallocs, encoded_alloc_lens);
/* Until the allocation actually takes place, the heap is in an invalid
state (see comments in [caml_memprof_track_young]). Hence, very little
heap operations are allowed before the actual allocation.
{
if (Caml_state->requested_major_slice || Caml_state->requested_minor_gc){
CAMLparam1 (extra_root);
- CAML_INSTR_INT ("force_minor/check_urgent_gc@", 1);
caml_gc_dispatch();
CAMLdrop;
}
static void realloc_generic_table
(struct generic_table *tbl, asize_t element_size,
- char * msg_intr_int, char *msg_threshold, char *msg_growing, char *msg_error)
+ ev_gc_counter ev_counter_name,
+ char *msg_threshold, char *msg_growing, char *msg_error)
{
CAMLassert (tbl->ptr == tbl->limit);
CAMLassert (tbl->limit <= tbl->end);
alloc_generic_table (tbl, Caml_state->minor_heap_wsz / 8, 256,
element_size);
}else if (tbl->limit == tbl->threshold){
- CAML_INSTR_INT (msg_intr_int, 1);
+ CAML_EV_COUNTER (ev_counter_name, 1);
caml_gc_message (0x08, msg_threshold, 0);
tbl->limit = tbl->end;
caml_request_minor_gc ();
{
realloc_generic_table
((struct generic_table *) tbl, sizeof (value *),
- "request_minor/realloc_ref_table@",
+ EV_C_REQUEST_MINOR_REALLOC_REF_TABLE,
"ref_table threshold crossed\n",
"Growing ref_table to %" ARCH_INTNAT_PRINTF_FORMAT "dk bytes\n",
"ref_table overflow");
{
realloc_generic_table
((struct generic_table *) tbl, sizeof (struct caml_ephe_ref_elt),
- "request_minor/realloc_ephe_ref_table@",
+ EV_C_REQUEST_MINOR_REALLOC_EPHE_REF_TABLE,
"ephe_ref_table threshold crossed\n",
"Growing ephe_ref_table to %" ARCH_INTNAT_PRINTF_FORMAT "dk bytes\n",
"ephe_ref_table overflow");
{
realloc_generic_table
((struct generic_table *) tbl, sizeof (struct caml_custom_elt),
- "request_minor/realloc_custom_table@",
+ EV_C_REQUEST_MINOR_REALLOC_CUSTOM_TABLE,
"custom_table threshold crossed\n",
"Growing custom_table to %" ARCH_INTNAT_PRINTF_FORMAT "dk bytes\n",
"custom_table overflow");
return 1;
}
-#ifdef CAML_INSTR
-/* Timers for profiling GC and allocation (experimental, Linux-only) */
-
-#include <limits.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-struct caml_instr_block *caml_instr_log = NULL;
-intnat caml_instr_starttime, caml_instr_stoptime;
-
-#define Get_time(p,i) ((p)->ts[(i)].tv_nsec + 1000000000 * (p)->ts[(i)].tv_sec)
-
-void caml_instr_init (void)
-{
- char *s;
-
- caml_instr_starttime = 0;
- s = caml_secure_getenv ("OCAML_INSTR_START");
- if (s != NULL) caml_instr_starttime = atol (s);
- caml_instr_stoptime = LONG_MAX;
- s = caml_secure_getenv ("OCAML_INSTR_STOP");
- if (s != NULL) caml_instr_stoptime = atol (s);
-}
-
-void caml_instr_atexit (void)
-{
- int i;
- struct caml_instr_block *p, *prev, *next;
- FILE *f = NULL;
- char *fname;
-
- fname = caml_secure_getenv ("OCAML_INSTR_FILE");
- if (fname != NULL){
- char *mode = "a";
- char buf [1000];
- char *name = fname;
-
- if (name[0] == '@'){
- snprintf (buf, sizeof(buf), "%s.%lld",
- name + 1, (long long) (getpid ()));
- name = buf;
- }
- if (name[0] == '+'){
- mode = "a";
- name = name + 1;
- }else if (name [0] == '>' || name[0] == '-'){
- mode = "w";
- name = name + 1;
- }
- f = fopen (name, mode);
- }
-
- if (f != NULL){
- /* reverse the list */
- prev = NULL;
- p = caml_instr_log;
- while (p != NULL){
- next = p->next;
- p->next = prev;
- prev = p;
- p = next;
- }
- caml_instr_log = prev;
- fprintf (f, "==== OCAML INSTRUMENTATION DATA %s\n", OCAML_VERSION_STRING);
- for (p = caml_instr_log; p != NULL; p = p->next){
- for (i = 0; i < p->index; i++){
- fprintf (f, "@@ %19ld %19ld %s\n",
- (long) Get_time (p, i),
- (long) Get_time(p, i+1),
- p->tag[i+1]);
- }
- if (p->tag[0][0] != '\000'){
- fprintf (f, "@@ %19ld %19ld %s\n",
- (long) Get_time (p, 0),
- (long) Get_time(p, p->index),
- p->tag[0]);
- }
- }
- fclose (f);
- }
-}
-#endif /* CAML_INSTR */
-
int caml_find_code_fragment(char *pc, int *index, struct code_fragment **cf)
{
struct code_fragment *cfi;
header_t hd = Hd_val (v);
tag_t tag = Tag_hd (hd);
color_t color = Color_hd (hd);
+ color_t frag_color = Is_young(v) ? 0 : Caml_black;
mlsize_t wosize = Wosize_hd (hd);
mlsize_t i;
look like a pointer because there may be some references to it in
ref_table. */
Field (v, new_wosize) =
- Make_header (Wosize_whsize (wosize-new_wosize), Abstract_tag, Caml_black);
+ Make_header (Wosize_whsize (wosize-new_wosize), Abstract_tag, frag_color);
Hd_val (v) =
Make_header_with_profinfo (new_wosize, tag, color, Profinfo_val(v));
return Val_unit;
lfdu 29, 8(11)
lfdu 30, 8(11)
lfdu 31, 8(11)
- /* Return to caller, restarting the allocation */
+ /* Return to caller, resuming the allocation */
lg 11, Caml_state(last_return_address)
- addi 11, 11, -16 /* Restart the allocation (4 instructions) */
mtlr 11
/* For PPC64: restore the TOC that the caller saved at the usual place */
#ifdef TOC_SAVE
/* Branch to handler */
bctr
.L121:
- li 0, 0
- stg 0, Caml_state(backtrace_pos)
mr 27, 3 /* preserve exn bucket in callee-save reg */
/* arg1: exception bucket, already in r3 */
lg 4, Caml_state(last_return_address) /* arg2: PC of raise */
--- /dev/null
+/**************************************************************************/
+/* */
+/* OCaml */
+/* */
+/* Nicolas Ojeda Bar <n.oje.bar@gmail.com> */
+/* */
+/* Copyright 2016 Institut National de Recherche en Informatique et */
+/* en Automatique. */
+/* */
+/* All rights reserved. This file is distributed under the terms of */
+/* the GNU Lesser General Public License version 2.1, with the */
+/* special exception on linking described in the file LICENSE. */
+/* */
+/**************************************************************************/
+
+/* Asm part of the runtime system, RISC-V processor, 64-bit mode */
+/* Must be preprocessed by cpp */
+
+#define ARG_DOMAIN_STATE_PTR t0
+#define DOMAIN_STATE_PTR s0
+#define TRAP_PTR s1
+#define ALLOC_PTR s10
+#define ALLOC_LIMIT s11
+#define TMP t1
+#define ARG t2
+
+#define STORE sd
+#define LOAD ld
+
+ .set domain_curr_field, 0
+#define DOMAIN_STATE(c_type, name) \
+ .equ domain_field_caml_##name, domain_curr_field ; \
+ .set domain_curr_field, domain_curr_field + 1
+#include "../runtime/caml/domain_state.tbl"
+#undef DOMAIN_STATE
+
+#define Caml_state(var) (8*domain_field_caml_##var)(s0)
+
+#define FUNCTION(name) \
+ .align 2; \
+ .globl name; \
+ .type name, @function; \
+name:
+
+#if defined(__PIC__)
+ .option pic
+#define PLT(r) r@plt
+#else
+ .option nopic
+#define PLT(r) r
+#endif
+
+ .section .text
+/* Invoke the garbage collector. */
+
+ .globl caml_system__code_begin
+caml_system__code_begin:
+
+FUNCTION(caml_call_gc)
+.Lcaml_call_gc:
+ /* Record return address */
+ STORE ra, Caml_state(last_return_address)
+ /* Record lowest stack address */
+ STORE sp, Caml_state(bottom_of_stack)
+ /* Set up stack space, saving return address */
+ /* (1 reg for RA, 1 reg for FP, 21 allocatable int regs,
+ 20 caller-save float regs) * 8 */
+ /* + 1 for alignment */
+ addi sp, sp, -0x160
+ STORE ra, 0x8(sp)
+ STORE s0, 0x0(sp)
+ /* Save allocatable integer registers on the stack,
+ in the order given in proc.ml */
+ STORE a0, 0x10(sp)
+ STORE a1, 0x18(sp)
+ STORE a2, 0x20(sp)
+ STORE a3, 0x28(sp)
+ STORE a4, 0x30(sp)
+ STORE a5, 0x38(sp)
+ STORE a6, 0x40(sp)
+ STORE a7, 0x48(sp)
+ STORE s2, 0x50(sp)
+ STORE s3, 0x58(sp)
+ STORE s4, 0x60(sp)
+ STORE s5, 0x68(sp)
+ STORE s6, 0x70(sp)
+ STORE s7, 0x78(sp)
+ STORE s8, 0x80(sp)
+ STORE s9, 0x88(sp)
+ STORE t2, 0x90(sp)
+ STORE t3, 0x98(sp)
+ STORE t4, 0xa0(sp)
+ STORE t5, 0xa8(sp)
+ STORE t6, 0xb0(sp)
+ /* Save caller-save floating-point registers on the stack
+ (callee-saves are preserved by caml_garbage_collection) */
+ fsd ft0, 0xb8(sp)
+ fsd ft1, 0xc0(sp)
+ fsd ft2, 0xc8(sp)
+ fsd ft3, 0xd0(sp)
+ fsd ft4, 0xd8(sp)
+ fsd ft5, 0xe0(sp)
+ fsd ft6, 0xe8(sp)
+ fsd ft7, 0xf0(sp)
+ fsd fa0, 0xf8(sp)
+ fsd fa1, 0x100(sp)
+ fsd fa2, 0x108(sp)
+ fsd fa3, 0x110(sp)
+ fsd fa4, 0x118(sp)
+ fsd fa5, 0x120(sp)
+ fsd fa6, 0x128(sp)
+ fsd fa7, 0x130(sp)
+ fsd ft8, 0x138(sp)
+ fsd ft9, 0x140(sp)
+ fsd ft9, 0x148(sp)
+ fsd ft10, 0x150(sp)
+ fsd ft11, 0x158(sp)
+ /* Store pointer to saved integer registers in caml_gc_regs */
+ addi TMP, sp, 0x10
+ STORE TMP, Caml_state(gc_regs)
+ /* Save current allocation pointer for debugging purposes */
+ STORE ALLOC_PTR, Caml_state(young_ptr)
+ /* Save trap pointer in case an exception is raised during GC */
+ STORE TRAP_PTR, Caml_state(exception_pointer)
+ /* Call the garbage collector */
+ call PLT(caml_garbage_collection)
+ /* Restore registers */
+ LOAD a0, 0x10(sp)
+ LOAD a1, 0x18(sp)
+ LOAD a2, 0x20(sp)
+ LOAD a3, 0x28(sp)
+ LOAD a4, 0x30(sp)
+ LOAD a5, 0x38(sp)
+ LOAD a6, 0x40(sp)
+ LOAD a7, 0x48(sp)
+ LOAD s2, 0x50(sp)
+ LOAD s3, 0x58(sp)
+ LOAD s4, 0x60(sp)
+ LOAD s5, 0x68(sp)
+ LOAD s6, 0x70(sp)
+ LOAD s7, 0x78(sp)
+ LOAD s8, 0x80(sp)
+ LOAD s9, 0x88(sp)
+ LOAD t2, 0x90(sp)
+ LOAD t3, 0x98(sp)
+ LOAD t4, 0xa0(sp)
+ LOAD t5, 0xa8(sp)
+ LOAD t6, 0xb0(sp)
+ fld ft0, 0xb8(sp)
+ fld ft1, 0xc0(sp)
+ fld ft2, 0xc8(sp)
+ fld ft3, 0xd0(sp)
+ fld ft4, 0xd8(sp)
+ fld ft5, 0xe0(sp)
+ fld ft6, 0xe8(sp)
+ fld ft7, 0xf0(sp)
+ fld fa0, 0xf8(sp)
+ fld fa1, 0x100(sp)
+ fld fa2, 0x108(sp)
+ fld fa3, 0x110(sp)
+ fld fa4, 0x118(sp)
+ fld fa5, 0x120(sp)
+ fld fa6, 0x128(sp)
+ fld fa7, 0x130(sp)
+ fld ft8, 0x138(sp)
+ fld ft9, 0x140(sp)
+ fld ft9, 0x148(sp)
+ fld ft10, 0x150(sp)
+ fld ft11, 0x158(sp)
+ /* Reload new allocation pointer and allocation limit */
+ LOAD ALLOC_PTR, Caml_state(young_ptr)
+ LOAD ALLOC_LIMIT, Caml_state(young_limit)
+ /* Free stack space and return to caller */
+ LOAD ra, 0x8(sp)
+ LOAD s0, 0x0(sp)
+ addi sp, sp, 0x160
+ ret
+ .size caml_call_gc, .-caml_call_gc
+
+/* Call a C function from OCaml */
+/* Function to call is in ARG */
+
+FUNCTION(caml_c_call)
+ /* Preserve return address in callee-save register s2 */
+ mv s2, ra
+ /* Record lowest stack address and return address */
+ STORE ra, Caml_state(last_return_address)
+ STORE sp, Caml_state(bottom_of_stack)
+ /* Make the exception handler alloc ptr available to the C code */
+ STORE ALLOC_PTR, Caml_state(young_ptr)
+ STORE TRAP_PTR, Caml_state(exception_pointer)
+ /* Call the function */
+ jalr ARG
+ /* Reload alloc ptr and alloc limit */
+ LOAD ALLOC_PTR, Caml_state(young_ptr)
+ LOAD ALLOC_LIMIT, Caml_state(young_limit)
+ /* Return */
+ jr s2
+ .size caml_c_call, .-caml_c_call
+
+/* Raise an exception from OCaml */
+FUNCTION(caml_raise_exn)
+ /* Test if backtrace is active */
+ LOAD TMP, Caml_state(backtrace_active)
+ bnez TMP, 2f
+1: /* Cut stack at current trap handler */
+ mv sp, TRAP_PTR
+ /* Pop previous handler and jump to it */
+ LOAD TMP, 8(sp)
+ LOAD TRAP_PTR, 0(sp)
+ addi sp, sp, 16
+ jr TMP
+2: /* Preserve exception bucket in callee-save register s2 */
+ mv s2, a0
+ /* Stash the backtrace */
+ mv a1, ra
+ mv a2, sp
+ mv a3, TRAP_PTR
+ call PLT(caml_stash_backtrace)
+ /* Restore exception bucket and raise */
+ mv a0, s2
+ j 1b
+ .size caml_raise_exn, .-caml_raise_exn
+
+ .globl caml_reraise_exn
+ .type caml_reraise_exn, @function
+
+/* Raise an exception from C */
+
+FUNCTION(caml_raise_exception)
+ mv DOMAIN_STATE_PTR, a0
+ mv a0, a1
+ LOAD TRAP_PTR, Caml_state(exception_pointer)
+ LOAD ALLOC_PTR, Caml_state(young_ptr)
+ LOAD ALLOC_LIMIT, Caml_state(young_limit)
+ LOAD TMP, Caml_state(backtrace_active)
+ bnez TMP, 2f
+1: /* Cut stack at current trap handler */
+ mv sp, TRAP_PTR
+ LOAD TMP, 8(sp)
+ LOAD TRAP_PTR, 0(sp)
+ addi sp, sp, 16
+ jr TMP
+2: /* Preserve exception bucket in callee-save register s2 */
+ mv s2, a0
+ LOAD a1, Caml_state(last_return_address)
+ LOAD a2, Caml_state(bottom_of_stack)
+ mv a3, TRAP_PTR
+ call PLT(caml_stash_backtrace)
+ mv a0, s2
+ j 1b
+ .size caml_raise_exception, .-caml_raise_exception
+
+/* Start the OCaml program */
+
+FUNCTION(caml_start_program)
+ mv ARG_DOMAIN_STATE_PTR, a0
+ la ARG, caml_program
+ /* Code shared with caml_callback* */
+ /* Address of OCaml code to call is in ARG */
+ /* Arguments to the OCaml code are in a0 ... a7 */
+.Ljump_to_caml:
+ /* Set up stack frame and save callee-save registers */
+ addi sp, sp, -0xd0
+ STORE ra, 0xc0(sp)
+ STORE s0, 0x0(sp)
+ STORE s1, 0x8(sp)
+ STORE s2, 0x10(sp)
+ STORE s3, 0x18(sp)
+ STORE s4, 0x20(sp)
+ STORE s5, 0x28(sp)
+ STORE s6, 0x30(sp)
+ STORE s7, 0x38(sp)
+ STORE s8, 0x40(sp)
+ STORE s9, 0x48(sp)
+ STORE s10, 0x50(sp)
+ STORE s11, 0x58(sp)
+ fsd fs0, 0x60(sp)
+ fsd fs1, 0x68(sp)
+ fsd fs2, 0x70(sp)
+ fsd fs3, 0x78(sp)
+ fsd fs4, 0x80(sp)
+ fsd fs5, 0x88(sp)
+ fsd fs6, 0x90(sp)
+ fsd fs7, 0x98(sp)
+ fsd fs8, 0xa0(sp)
+ fsd fs9, 0xa8(sp)
+ fsd fs10, 0xb0(sp)
+ fsd fs11, 0xb8(sp)
+ addi sp, sp, -32
+ /* Load domain state pointer from argument */
+ mv DOMAIN_STATE_PTR, ARG_DOMAIN_STATE_PTR
+ /* Setup a callback link on the stack */
+ LOAD TMP, Caml_state(bottom_of_stack)
+ STORE TMP, 0(sp)
+ LOAD TMP, Caml_state(last_return_address)
+ STORE TMP, 8(sp)
+ LOAD TMP, Caml_state(gc_regs)
+ STORE TMP, 16(sp)
+ /* set up a trap frame */
+ addi sp, sp, -16
+ LOAD TMP, Caml_state(exception_pointer)
+ STORE TMP, 0(sp)
+ lla TMP, .Ltrap_handler
+ STORE TMP, 8(sp)
+ mv TRAP_PTR, sp
+ LOAD ALLOC_PTR, Caml_state(young_ptr)
+ LOAD ALLOC_LIMIT, Caml_state(young_limit)
+ STORE x0, Caml_state(last_return_address)
+ jalr ARG
+.Lcaml_retaddr: /* pop trap frame, restoring caml_exception_pointer */
+ LOAD TMP, 0(sp)
+ STORE TMP, Caml_state(exception_pointer)
+ addi sp, sp, 16
+.Lreturn_result: /* pop callback link, restoring global variables */
+ LOAD TMP, 0(sp)
+ STORE TMP, Caml_state(bottom_of_stack)
+ LOAD TMP, 8(sp)
+ STORE TMP, Caml_state(last_return_address)
+ LOAD TMP, 16(sp)
+ STORE TMP, Caml_state(gc_regs)
+ addi sp, sp, 32
+ /* Update allocation pointer */
+ STORE ALLOC_PTR, Caml_state(young_ptr)
+ /* reload callee-save registers and return */
+ LOAD ra, 0xc0(sp)
+ LOAD s0, 0x0(sp)
+ LOAD s1, 0x8(sp)
+ LOAD s2, 0x10(sp)
+ LOAD s3, 0x18(sp)
+ LOAD s4, 0x20(sp)
+ LOAD s5, 0x28(sp)
+ LOAD s6, 0x30(sp)
+ LOAD s7, 0x38(sp)
+ LOAD s8, 0x40(sp)
+ LOAD s9, 0x48(sp)
+ LOAD s10, 0x50(sp)
+ LOAD s11, 0x58(sp)
+ fld fs0, 0x60(sp)
+ fld fs1, 0x68(sp)
+ fld fs2, 0x70(sp)
+ fld fs3, 0x78(sp)
+ fld fs4, 0x80(sp)
+ fld fs5, 0x88(sp)
+ fld fs6, 0x90(sp)
+ fld fs7, 0x98(sp)
+ fld fs8, 0xa0(sp)
+ fld fs9, 0xa8(sp)
+ fld fs10, 0xb0(sp)
+ fld fs11, 0xb8(sp)
+ addi sp, sp, 0xd0
+ ret
+ .type .Lcaml_retaddr, @function
+ .size .Lcaml_retaddr, .-.Lcaml_retaddr
+ .size caml_start_program, .-caml_start_program
+
+ .align 2
+.Ltrap_handler:
+ STORE TRAP_PTR, Caml_state(exception_pointer)
+ ori a0, a0, 2
+ j .Lreturn_result
+ .type .Ltrap_handler, @function
+ .size .Ltrap_handler, .-.Ltrap_handler
+
+/* Callback from C to OCaml */
+
+FUNCTION(caml_callback_asm)
+ /* Initial shuffling of arguments */
+ /* a0 = Caml_state, a1 = closure, (a2) = args */
+ mv ARG_DOMAIN_STATE_PTR, a0
+ LOAD a0, 0(a2) /* a0 = first arg */
+ /* a1 = closure environment */
+ LOAD ARG, 0(a1) /* code pointer */
+ j .Ljump_to_caml
+ .size caml_callback_asm, .-caml_callback_asm
+
+FUNCTION(caml_callback2_asm)
+ /* Initial shuffling of arguments */
+ /* a0 = Caml_state, a1 = closure, (a2) = args */
+ mv ARG_DOMAIN_STATE_PTR, a0
+ mv TMP, a1
+ LOAD a0, 0(a2)
+ LOAD a1, 8(a2)
+ mv a2, TMP
+ la ARG, caml_apply2
+ j .Ljump_to_caml
+ .size caml_callback2_asm, .-caml_callback2_asm
+
+FUNCTION(caml_callback3_asm)
+ /* Initial shuffling of arguments */
+ /* a0 = Caml_state, a1 = closure, (a2) = args */
+ mv ARG_DOMAIN_STATE_PTR, a0
+ mv a3, a1
+ LOAD a0, 0(a2)
+ LOAD a1, 8(a2)
+ LOAD a2, 16(a2)
+ la ARG, caml_apply3
+ j .Ljump_to_caml
+ .size caml_callback3_asm, .-caml_callback3_asm
+
+FUNCTION(caml_ml_array_bound_error)
+ /* Load address of [caml_array_bound_error] in ARG */
+ la ARG, caml_array_bound_error
+ /* Call that function */
+ tail caml_c_call
+ .size caml_ml_array_bound_error, .-caml_ml_array_bound_error
+
+ .globl caml_system__code_end
+caml_system__code_end:
+
+/* GC roots for callback */
+
+ .section .data
+ .align 3
+ .globl caml_system__frametable
+ .type caml_system__frametable, @object
+caml_system__frametable:
+ .quad 1 /* one descriptor */
+ .quad .Lcaml_retaddr /* return address into callback */
+ .short -1 /* negative frame size => use callback link */
+ .short 0 /* no roots */
+ .align 3
+ .size caml_system__frametable, .-caml_system__frametable
#include "caml/roots.h"
#include "caml/stacks.h"
#include "caml/memprof.h"
+#include "caml/eventlog.h"
CAMLexport void (*caml_scan_roots_hook) (scanning_action f) = NULL;
/* Finalised values */
caml_final_oldify_young_roots ();
/* Memprof */
- caml_memprof_scan_roots (&caml_oldify_one);
+ caml_memprof_oldify_young_roots ();
/* Hook */
if (caml_scan_roots_hook != NULL) (*caml_scan_roots_hook)(&caml_oldify_one);
}
ignored and [caml_darken_all_roots_slice] does nothing. */
void caml_do_roots (scanning_action f, int do_globals)
{
- CAML_INSTR_SETUP (tmr, "major_roots");
/* Global variables */
+ CAML_EV_BEGIN(EV_MAJOR_ROOTS_GLOBAL);
f(caml_global_data, &caml_global_data);
- CAML_INSTR_TIME (tmr, "major_roots/global");
+ CAML_EV_END(EV_MAJOR_ROOTS_GLOBAL);
/* The stack and the local C roots */
+ CAML_EV_BEGIN(EV_MAJOR_ROOTS_LOCAL);
caml_do_local_roots(f, Caml_state->extern_sp, Caml_state->stack_high,
Caml_state->local_roots);
- CAML_INSTR_TIME (tmr, "major_roots/local");
+ CAML_EV_END(EV_MAJOR_ROOTS_LOCAL);
/* Global C roots */
+ CAML_EV_BEGIN(EV_MAJOR_ROOTS_C);
caml_scan_global_roots(f);
- CAML_INSTR_TIME (tmr, "major_roots/C");
+ CAML_EV_END(EV_MAJOR_ROOTS_C);
/* Finalised values */
+ CAML_EV_BEGIN(EV_MAJOR_ROOTS_FINALISED);
caml_final_do_roots (f);
- CAML_INSTR_TIME (tmr, "major_roots/finalised");
+ CAML_EV_END(EV_MAJOR_ROOTS_FINALISED);
/* Memprof */
- caml_memprof_scan_roots (f);
- CAML_INSTR_TIME (tmr, "major_roots/memprof");
+ CAML_EV_BEGIN(EV_MAJOR_ROOTS_MEMPROF);
+ caml_memprof_do_roots (f);
+ CAML_EV_END(EV_MAJOR_ROOTS_MEMPROF);
/* Hook */
+ CAML_EV_BEGIN(EV_MAJOR_ROOTS_HOOK);
if (caml_scan_roots_hook != NULL) (*caml_scan_roots_hook)(f);
- CAML_INSTR_TIME (tmr, "major_roots/hook");
+ CAML_EV_END(EV_MAJOR_ROOTS_HOOK);
}
CAMLexport void caml_do_local_roots (scanning_action f, value *stack_low,
#include "caml/stack.h"
#include "caml/roots.h"
#include "caml/memprof.h"
+#include "caml/eventlog.h"
#include <string.h>
#include <stdio.h>
}
static frame_descr * next_frame_descr(frame_descr * d) {
- uintnat nextd;
- nextd =
- ((uintnat)d +
- sizeof(char *) + sizeof(short) + sizeof(short) +
- sizeof(short) * d->num_live + sizeof(frame_descr *) - 1)
- & -sizeof(frame_descr *);
- if (d->frame_size & 1) nextd += sizeof(void *); /* pointer to debuginfo */
- return((frame_descr *) nextd);
+ unsigned char num_allocs = 0, *p;
+ CAMLassert(d->retaddr >= 4096);
+ /* Skip to end of live_ofs */
+ p = (unsigned char*)&d->live_ofs[d->num_live];
+ /* Skip alloc_lengths if present */
+ if (d->frame_size & 2) {
+ num_allocs = *p;
+ p += num_allocs + 1;
+ }
+ /* Skip debug info if present */
+ if (d->frame_size & 1) {
+ /* Align to 32 bits */
+ p = Align_to(p, uint32_t);
+ p += sizeof(uint32_t) * (d->frame_size & 2 ? num_allocs : 1);
+ }
+ /* Align to word size */
+ p = Align_to(p, void*);
+ return ((frame_descr*) p);
}
static void fill_hashtable(link *frametables) {
/* Finalised values */
caml_final_oldify_young_roots ();
/* Memprof */
- caml_memprof_scan_roots (&caml_oldify_one);
+ caml_memprof_oldify_young_roots ();
/* Hook */
if (caml_scan_roots_hook != NULL) (*caml_scan_roots_hook)(&caml_oldify_one);
}
static int do_resume = 0;
static mlsize_t roots_count = 0;
intnat remaining_work = work;
- CAML_INSTR_SETUP (tmr, "");
+ CAML_EV_BEGIN(EV_MAJOR_MARK_GLOBAL_ROOTS_SLICE);
/* If the loop was started in a previous call, resume it. */
if (do_resume) goto resume;
suspend:
/* Do this in both cases. */
- CAML_INSTR_TIME (tmr, "major/mark/global_roots_slice");
+ CAML_EV_END(EV_MAJOR_MARK_GLOBAL_ROOTS_SLICE);
return remaining_work;
}
int i, j;
value * glob;
link *lnk;
- CAML_INSTR_SETUP (tmr, "major_roots");
+ CAML_EV_BEGIN(EV_MAJOR_ROOTS_DYNAMIC_GLOBAL);
if (do_globals){
/* The global roots */
for (i = 0; caml_globals[i] != 0; i++) {
}
}
}
- CAML_INSTR_TIME (tmr, "major_roots/dynamic_global");
+ CAML_EV_END(EV_MAJOR_ROOTS_DYNAMIC_GLOBAL);
/* The stack and local roots */
+ CAML_EV_BEGIN(EV_MAJOR_ROOTS_LOCAL);
caml_do_local_roots(f, Caml_state->bottom_of_stack,
Caml_state->last_return_address, Caml_state->gc_regs,
Caml_state->local_roots);
- CAML_INSTR_TIME (tmr, "major_roots/local");
+ CAML_EV_END(EV_MAJOR_ROOTS_LOCAL);
/* Global C roots */
+ CAML_EV_BEGIN(EV_MAJOR_ROOTS_C);
caml_scan_global_roots(f);
- CAML_INSTR_TIME (tmr, "major_roots/C");
+ CAML_EV_END(EV_MAJOR_ROOTS_C);
/* Finalised values */
+ CAML_EV_BEGIN(EV_MAJOR_ROOTS_FINALISED);
caml_final_do_roots (f);
- CAML_INSTR_TIME (tmr, "major_roots/finalised");
+ CAML_EV_END(EV_MAJOR_ROOTS_FINALISED);
/* Memprof */
- caml_memprof_scan_roots (f);
- CAML_INSTR_TIME (tmr, "major_roots/memprof");
+ CAML_EV_BEGIN(EV_MAJOR_ROOTS_MEMPROF);
+ caml_memprof_do_roots (f);
+ CAML_EV_END(EV_MAJOR_ROOTS_MEMPROF);
/* Hook */
+ CAML_EV_BEGIN(EV_MAJOR_ROOTS_HOOK);
if (caml_scan_roots_hook != NULL) (*caml_scan_roots_hook)(f);
- CAML_INSTR_TIME (tmr, "major_roots/hook");
+ CAML_EV_END(EV_MAJOR_ROOTS_HOOK);
}
void caml_do_local_roots(scanning_action f, char * bottom_of_stack,
/* Branch to handler */
br %r1;
.L112:
- lgfi %r0, 0
- stg %r0, Caml_state(backtrace_pos)
ldgr %f15,%r2 /* preserve exn bucket in callee-save reg */
/* arg1: exception bucket, already in r2 */
lg %r3, Caml_state(last_return_address) /* arg2: PC of raise */
}
CAMLno_tsan /* The access to [caml_something_to_do] is not synchronized. */
-static inline value process_pending_actions_with_root_exn(value extra_root)
+Caml_inline value process_pending_actions_with_root_exn(value extra_root)
{
if (caml_something_to_do) {
CAMLparam1(extra_root);
void caml_garbage_collection(void)
{
- /* TEMPORARY: if we have just sampled an allocation in native mode,
- we simply renew the sample to ignore it. Otherwise, renewing now
- will not have any effect on the sampling distribution, because of
- the memorylessness of the Bernoulli process.
-
- FIXME: if the sampling rate is 1, this leads to infinite loop,
- because we are using a binomial distribution in [memprof.c]. This
- will go away when the sampling of natively allocated blocks will
- be correctly implemented.
- */
- caml_memprof_renew_minor_sample();
- if (Caml_state->requested_major_slice || Caml_state->requested_minor_gc ||
- Caml_state->young_ptr - Caml_state->young_trigger < Max_young_whsize){
- caml_gc_dispatch ();
+ frame_descr* d;
+ intnat allocsz = 0, i, nallocs;
+ unsigned char* alloc_len;
+
+ { /* Find the frame descriptor for the current allocation */
+ uintnat h = Hash_retaddr(Caml_state->last_return_address);
+ while (1) {
+ d = caml_frame_descriptors[h];
+ if (d->retaddr == Caml_state->last_return_address) break;
+ h = (h + 1) & caml_frame_descriptors_mask;
+ }
+ /* Must be an allocation frame */
+ CAMLassert(d && d->frame_size != 0xFFFF && (d->frame_size & 2));
}
-#ifdef WITH_SPACETIME
- if (Caml_state->young_ptr == Caml_state->young_alloc_end) {
- caml_spacetime_automatic_snapshot();
+ /* Compute the total allocation size at this point,
+ including allocations combined by Comballoc */
+ alloc_len = (unsigned char*)(&d->live_ofs[d->num_live]);
+ nallocs = *alloc_len++;
+ for (i = 0; i < nallocs; i++) {
+ allocsz += Whsize_wosize(Wosize_encoded_alloc_len(alloc_len[i]));
}
-#endif
+ /* We have computed whsize (including header), but need wosize (without) */
+ allocsz -= 1;
- caml_raise_if_exception(caml_do_pending_actions_exn());
+ caml_alloc_small_dispatch(allocsz, CAML_DO_TRACK | CAML_FROM_CAML,
+ nallocs, alloc_len);
}
DECLARE_SIGNAL_HANDLER(handle_signal)
#ifdef _WIN32
#define strdup_os wcsdup
-#define snprintf_os _snwprintf
#else
#define strdup_os strdup
-#define snprintf_os snprintf
#endif
static void reinitialise_free_node_block(void)
#endif
#include "caml/osdeps.h"
#include "caml/startup_aux.h"
+#include "caml/memprof.h"
#ifdef _WIN32
call_registered_value("Pervasives.do_at_exit");
call_registered_value("Thread.at_shutdown");
caml_finalise_heap();
+ caml_memprof_shutdown();
caml_free_locale();
#ifndef NATIVE_CODE
caml_free_shared_libs();
#include "caml/debugger.h"
#include "caml/domain.h"
#include "caml/dynlink.h"
+#include "caml/eventlog.h"
#include "caml/exec.h"
#include "caml/fail.h"
#include "caml/fix_code.h"
static char magicstr[EXEC_MAGIC_LENGTH+1];
static int print_magic = 0;
+/* Print the specified error message followed by an end-of-line and exit */
+static void error(char *msg, ...)
+{
+ va_list ap;
+ va_start(ap, msg);
+ vfprintf (stderr, msg, ap);
+ va_end(ap);
+ fprintf(stderr, "\n");
+ exit(127);
+}
+
/* Read the trailer of a bytecode file */
static void fixup_endianness_trailer(uint32_t * p)
exit(0);
break;
default:
- fprintf(stderr, "unknown option %s", caml_stat_strdup_of_os(argv[i]));
- exit(127);
+ error("unknown option %s", caml_stat_strdup_of_os(argv[i]));
}
}
return i;
caml_verb_gc = 0x3F;
#endif
caml_parse_ocamlrunparam();
+ CAML_EVENTLOG_INIT();
#ifdef DEBUG
caml_gc_message (-1, "### OCaml runtime: debug mode ###\n");
#endif
if (fd < 0) {
pos = parse_command_line(argv);
if (argv[pos] == 0) {
- fprintf(stderr, "no bytecode file specified");
- exit(127);
+ error("no bytecode file specified");
}
exe_name = argv[pos];
fd = caml_attempt_open(&exe_name, &trail, 1);
switch(fd) {
case FILE_NOT_FOUND:
- fprintf(stderr, "cannot find file '%s'",
+ error("cannot find file '%s'",
caml_stat_strdup_of_os(argv[pos]));
- exit(127);
break;
case BAD_BYTECODE:
- fprintf(stderr,
+ error(
"the file '%s' is not a bytecode executable file",
caml_stat_strdup_of_os(exe_name));
- exit(127);
break;
case WRONG_MAGIC:
- fprintf(stderr,
+ error(
"the file '%s' has not the right magic number: "\
"expected %s, got %s",
caml_stat_strdup_of_os(exe_name),
EXEC_MAGIC,
magicstr);
- exit(127);
break;
}
}
caml_verb_gc = 0x3F;
#endif
caml_parse_ocamlrunparam();
+ CAML_EVENTLOG_INIT();
#ifdef DEBUG
caml_gc_message (-1, "### OCaml runtime: debug mode ###\n");
#endif
#include "caml/custom.h"
#include "caml/debugger.h"
#include "caml/domain.h"
+#include "caml/eventlog.h"
#include "caml/fail.h"
#include "caml/freelist.h"
#include "caml/gc.h"
caml_verb_gc = 0x3F;
#endif
caml_parse_ocamlrunparam();
+ CAML_EVENTLOG_INIT();
#ifdef DEBUG
caml_gc_message (-1, "### OCaml runtime: debug mode ###\n");
#endif
#ifndef NATIVE_CODE
caml_debugger(PROGRAM_EXIT, Val_unit);
#endif
- caml_instr_atexit ();
if (caml_cleanup_on_exit)
caml_shutdown();
#ifdef _WIN32
#include "caml/weak.h"
#include "caml/minor_gc.h"
#include "caml/signals.h"
+#include "caml/eventlog.h"
value caml_ephe_list_head = 0;
/** The minor heap is considered alive. */
#if defined (NATIVE_CODE) && defined (NO_NAKED_POINTERS)
/** Outside minor and major heap, x must be black. */
-static inline int Is_Dead_during_clean(value x)
+Caml_inline int Is_Dead_during_clean(value x)
{
CAMLassert (x != caml_ephe_none);
CAMLassert (caml_gc_phase == Phase_clean);
/** The minor heap doesn't have to be marked, outside they should
already be black
*/
-static inline int Must_be_Marked_during_mark(value x)
+Caml_inline int Must_be_Marked_during_mark(value x)
{
CAMLassert (x != caml_ephe_none);
CAMLassert (caml_gc_phase == Phase_mark);
return Is_block (x) && !Is_young (x);
}
#else
-static inline int Is_Dead_during_clean(value x)
+Caml_inline int Is_Dead_during_clean(value x)
{
CAMLassert (x != caml_ephe_none);
CAMLassert (caml_gc_phase == Phase_clean);
return Is_block (x) && Is_in_heap (x) && Is_white_val(x);
}
-static inline int Must_be_Marked_during_mark(value x)
+Caml_inline int Must_be_Marked_during_mark(value x)
{
CAMLassert (x != caml_ephe_none);
CAMLassert (caml_gc_phase == Phase_mark);
/* If we are in Phase_clean we need to do as if the key is empty when
it will be cleaned during this phase */
-static inline int is_ephe_key_none(value ar, mlsize_t offset)
+Caml_inline int is_ephe_key_none(value ar, mlsize_t offset)
{
value elt = Field (ar, offset);
if (elt == caml_ephe_none){
}
-static inline void copy_value(value src, value dst)
+Caml_inline void copy_value(value src, value dst)
{
if (Tag_val (src) < No_scan_tag){
mlsize_t i;
CAMLassert(loop < 10);
if(8 == loop){ /** One minor gc must be enough */
elt = Val_unit;
- CAML_INSTR_INT ("force_minor/weak@", 1);
+ CAML_EV_COUNTER (EV_C_FORCE_MINOR_WEAK, 1);
caml_minor_collection ();
} else {
/* cases where loop is between 0 to 7 and where loop is equal to 9 */
CAMLassert(loop < 10);
if(8 == loop){ /** One minor gc must be enough */
elt = Val_unit;
- CAML_INSTR_INT ("force_minor/weak@", 1);
+ CAML_EV_COUNTER (EV_C_FORCE_MINOR_WEAK, 1);
caml_minor_collection ();
} else {
/* cases where loop is between 0 to 7 and where loop is equal to 9 */
offset_d += CAML_EPHE_FIRST_KEY;
if (caml_gc_phase == Phase_clean){
- caml_ephe_clean(ars);
- caml_ephe_clean(ard);
+ caml_ephe_clean_partial(ars, offset_s, offset_s + length);
+ /* We don't need to clean the keys that are about to be overwritten,
+ except where cleaning them could result in releasing the data,
+ which can't happen if data is already released. */
+ if (Field (ard, CAML_EPHE_DATA_OFFSET) != caml_ephe_none)
+ caml_ephe_clean_partial(ard, offset_d, offset_d + length);
}
if (offset_d < offset_s){
for (i = 0; i < length; i++){
/* snprintf emulation */
-#if defined(_WIN32) && !defined(_UCRT)
-int caml_snprintf(char * buf, size_t size, const char * format, ...)
-{
- int len;
- va_list args;
-
- if (size > 0) {
- va_start(args, format);
- len = _vsnprintf(buf, size, format, args);
- va_end(args);
- if (len >= 0 && len < size) {
- /* [len] characters were stored in [buf],
- a null-terminator was appended. */
- return len;
- }
- /* [size] characters were stored in [buf], without null termination.
- Put a null terminator, truncating the output. */
- buf[size - 1] = 0;
- }
- /* Compute the actual length of output, excluding null terminator */
- va_start(args, format);
- len = _vscprintf(format, args);
- va_end(args);
- return len;
+#define CAML_SNPRINTF(_vsnprintf, _vscprintf) \
+{ \
+ int len; \
+ va_list args; \
+\
+ if (size > 0) { \
+ va_start(args, format); \
+ len = _vsnprintf(buf, size, format, args); \
+ va_end(args); \
+ if (len >= 0 && len < size) { \
+ /* [len] characters were stored in [buf], \
+ a null-terminator was appended. */ \
+ return len; \
+ } \
+ /* [size] characters were stored in [buf], without null termination. \
+ Put a null terminator, truncating the output. */ \
+ buf[size - 1] = 0; \
+ } \
+ /* Compute the actual length of output, excluding null terminator */ \
+ va_start(args, format); \
+ len = _vscprintf(format, args); \
+ va_end(args); \
+ return len; \
}
+
+#ifndef _UCRT
+int caml_snprintf(char * buf, size_t size, const char * format, ...)
+CAML_SNPRINTF(_vsnprintf, _vscprintf)
#endif
+int caml_snwprintf(wchar_t * buf, size_t size, const wchar_t * format, ...)
+CAML_SNPRINTF(_vsnwprintf, _vscwprintf)
+
+#undef CAML_SNPRINTF
+
wchar_t *caml_secure_getenv (wchar_t const *var)
{
/* Win32 doesn't have a notion of setuid bit, so getenv is safe. */
return v;
}
-CAMLexport inline wchar_t* caml_stat_strdup_to_utf16(const char *s)
+CAMLexport wchar_t* caml_stat_strdup_to_utf16(const char *s)
{
wchar_t * ws;
int retcode;
stdlib__sys.cmi \
stdlib__string.cmi \
stdlib__printf.cmi \
+ stdlib__printexc.cmi \
stdlib__gc.cmi
stdlib__gc.cmx : \
stdlib__sys.cmx \
stdlib__string.cmx \
stdlib__printf.cmx \
+ stdlib__printexc.cmx \
stdlib__gc.cmi
-stdlib__gc.cmi :
+stdlib__gc.cmi : \
+ stdlib__printexc.cmi
stdlib__genlex.cmo : \
stdlib__string.cmi \
stdlib__stream.cmi \
the same style as the rest of the code, in particular the
alphabetical ordering and whitespace alignment of module aliases.
-* Add `$(P)module_name` to the definition of `STDLIB_MODULES` in
+* Add `module_name` to the definition of `STDLIB_MODS` in
`stdlib/StdlibModules`. You must keep the list sorted in dependency order.
* Run `make alldepend` to update all the `.depend` files. These files are not
ROOTDIR = ..
-include $(ROOTDIR)/Makefile.config
-include $(ROOTDIR)/Makefile.common
+-include $(ROOTDIR)/Makefile.config
+-include $(ROOTDIR)/Makefile.common
TARGET_BINDIR ?= $(BINDIR)
OC_CPPFLAGS += -I$(ROOTDIR)/runtime
-# Object file prefix
-P=stdlib__
-
include StdlibModules
OBJS=$(addsuffix .cmo,$(STDLIB_MODULES))
$(OTHERS:.cmo=.cmx) std_exit.cmx: stdlib.cmx
clean::
- rm -f *.cm* *.$(O) *.$(A) *.odoc
+ rm -f *.cm* *.o *.obj *.a *.lib *.odoc
rm -f camlheader*
include .depend
#**************************************************************************
# This file lists all standard library modules.
-# It is used in particular to know what to expunge in toplevels.
+# It is used by:
+# 1. stdlib/Makefile when building stdlib.cma
+# 2. Makefile to expunge the toplevels
+# 3. ocamldoc/Makefile.docfiles to compute all documentation files
+# which need to be generated for the stdlib
-P ?= stdlib__
+# add stdlib__ as prefix to a module except for internal modules
+# and the stdlib module itself
+define add_stdlib_prefix
+ $(or $(filter stdlib camlinternal%,$1), stdlib__$1)
+endef
# Modules should be listed in dependency order.
+STDLIB_MODS=\
+ camlinternalFormatBasics stdlib pervasives seq option result bool char uchar \
+ sys list bytes string unit marshal obj array float int int32 int64 nativeint \
+ lexing parsing set map stack queue camlinternalLazy lazy stream buffer \
+ camlinternalFormat printf arg printexc fun gc digest random hashtbl weak \
+ format scanf callback camlinternalOO oo camlinternalMod genlex ephemeron \
+ filename complex arrayLabels listLabels bytesLabels stringLabels moreLabels \
+ stdLabels spacetime bigarray
STDLIB_MODULES=\
- camlinternalFormatBasics \
- stdlib \
- $(P)pervasives \
- $(P)seq \
- $(P)option \
- $(P)result \
- $(P)bool \
- $(P)char \
- $(P)uchar \
- $(P)sys \
- $(P)list \
- $(P)bytes \
- $(P)string \
- $(P)unit \
- $(P)marshal \
- $(P)obj \
- $(P)array \
- $(P)float \
- $(P)int \
- $(P)int32 \
- $(P)int64 \
- $(P)nativeint \
- $(P)lexing \
- $(P)parsing \
- $(P)set \
- $(P)map \
- $(P)stack \
- $(P)queue \
- camlinternalLazy \
- $(P)lazy \
- $(P)stream \
- $(P)buffer \
- camlinternalFormat \
- $(P)printf \
- $(P)arg \
- $(P)printexc \
- $(P)fun \
- $(P)gc \
- $(P)digest \
- $(P)random \
- $(P)hashtbl \
- $(P)weak \
- $(P)format \
- $(P)scanf \
- $(P)callback \
- camlinternalOO \
- $(P)oo \
- camlinternalMod \
- $(P)genlex \
- $(P)ephemeron \
- $(P)filename \
- $(P)complex \
- $(P)arrayLabels \
- $(P)listLabels \
- $(P)bytesLabels \
- $(P)stringLabels \
- $(P)moreLabels \
- $(P)stdLabels \
- $(P)spacetime \
- $(P)bigarray
+ $(foreach module, $(STDLIB_MODS), $(call add_stdlib_prefix,$(module)))
else false in
loop 0
+let for_all2 p l1 l2 =
+ let n1 = length l1
+ and n2 = length l2 in
+ if n1 <> n2 then invalid_arg "Array.for_all2"
+ else let rec loop i =
+ if i = n1 then true
+ else if p (unsafe_get l1 i) (unsafe_get l2 i) then loop (succ i)
+ else false in
+ loop 0
+
+let exists2 p l1 l2 =
+ let n1 = length l1
+ and n2 = length l2 in
+ if n1 <> n2 then invalid_arg "Array.exists2"
+ else let rec loop i =
+ if i = n1 then false
+ else if p (unsafe_get l1 i) (unsafe_get l2 i) then true
+ else loop (succ i) in
+ loop 0
+
let mem x a =
let n = length a in
let rec loop i =
The first element has number 0.
The last element has number [Array.length a - 1].
You can also write [a.(n)] instead of [Array.get a n].
-
- Raise [Invalid_argument]
+ @raise Invalid_argument
if [n] is outside the range 0 to [(Array.length a - 1)]. *)
external set : 'a array -> int -> 'a -> unit = "%array_safe_set"
(** [Array.set a n x] modifies array [a] in place, replacing
element number [n] with [x].
You can also write [a.(n) <- x] instead of [Array.set a n x].
-
- Raise [Invalid_argument]
+ @raise Invalid_argument
if [n] is outside the range 0 to [Array.length a - 1]. *)
external make : int -> 'a -> 'a array = "caml_make_vect"
Consequently, if [x] is mutable, it is shared among all elements
of the array, and modifying [x] through one of the array entries
will modify all other entries at the same time.
-
- Raise [Invalid_argument] if [n < 0] or [n > Sys.max_array_length].
+ @raise Invalid_argument if [n < 0] or [n > Sys.max_array_length].
If the value of [x] is a floating-point number, then the maximum
size is only [Sys.max_array_length / 2].*)
with element number [i] initialized to the result of [f i].
In other terms, [Array.init n f] tabulates the results of [f]
applied to the integers [0] to [n-1].
-
- Raise [Invalid_argument] if [n < 0] or [n > Sys.max_array_length].
+ @raise Invalid_argument if [n < 0] or [n > Sys.max_array_length].
If the return type of [f] is [float], then the maximum
size is only [Sys.max_array_length / 2].*)
are initially physically equal to [e].
The element ([x,y]) of a matrix [m] is accessed
with the notation [m.(x).(y)].
-
- Raise [Invalid_argument] if [dimx] or [dimy] is negative or
+ @raise Invalid_argument if [dimx] or [dimy] is negative or
greater than {!Sys.max_array_length}.
If the value of [e] is a floating-point number, then the maximum
size is only [Sys.max_array_length / 2]. *)
val append : 'a array -> 'a array -> 'a array
(** [Array.append v1 v2] returns a fresh array containing the
concatenation of the arrays [v1] and [v2].
-
- Raise [Invalid_argument] if
+ @raise Invalid_argument if
[Array.length v1 + Array.length v2 > Sys.max_array_length]. *)
val concat : 'a array list -> 'a array
(** [Array.sub a start len] returns a fresh array of length [len],
containing the elements number [start] to [start + len - 1]
of array [a].
-
- Raise [Invalid_argument] if [start] and [len] do not
+ @raise Invalid_argument if [start] and [len] do not
designate a valid subarray of [a]; that is, if
[start < 0], or [len < 0], or [start + len > Array.length a]. *)
val fill : 'a array -> int -> int -> 'a -> unit
(** [Array.fill a ofs len x] modifies the array [a] in place,
storing [x] in elements number [ofs] to [ofs + len - 1].
-
- Raise [Invalid_argument] if [ofs] and [len] do not
+ @raise Invalid_argument if [ofs] and [len] do not
designate a valid subarray of [a]. *)
val blit : 'a array -> int -> 'a array -> int -> int -> unit
starting at element number [o2]. It works correctly even if
[v1] and [v2] are the same array, and the source and
destination chunks overlap.
-
- Raise [Invalid_argument] if [o1] and [len] do not
+ @raise Invalid_argument if [o1] and [len] do not
designate a valid subarray of [v1], or if [o2] and [len] do not
designate a valid subarray of [v2]. *)
val of_list : 'a list -> 'a array
(** [Array.of_list l] returns a fresh array containing the elements
of [l].
-
- Raise [Invalid_argument] if the length of [l] is greater than
+ @raise Invalid_argument if the length of [l] is greater than
[Sys.max_array_length].*)
val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit
(** [Array.iter2 f a b] applies function [f] to all the elements of [a]
and [b].
- Raise [Invalid_argument] if the arrays are not the same size.
+ @raise Invalid_argument if the arrays are not the same size.
@since 4.03.0 *)
val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
(** [Array.map2 f a b] applies function [f] to all the elements of [a]
and [b], and builds an array with the results returned by [f]:
[[| f a.(0) b.(0); ...; f a.(Array.length a - 1) b.(Array.length b - 1)|]].
- Raise [Invalid_argument] if the arrays are not the same size.
+ @raise Invalid_argument if the arrays are not the same size.
@since 4.03.0 *)
[(p a1) || (p a2) || ... || (p an)].
@since 4.03.0 *)
+val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool
+(** Same as {!Array.for_all}, but for a two-argument predicate.
+ @raise Invalid_argument if the two arrays have different lengths.
+ @since 4.11.0 *)
+
+val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool
+(** Same as {!Array.exists}, but for a two-argument predicate.
+ @raise Invalid_argument if the two arrays have different lengths.
+ @since 4.11.0 *)
+
val mem : 'a -> 'a array -> bool
(** [mem a l] is true if and only if [a] is structurally equal
to an element of [l] (i.e. there is an [x] in [l] such that
[(f a1) && (f a2) && ... && (f an)].
@since 4.03.0 *)
+val for_all2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool
+(** Same as {!ArrayLabels.for_all}, but for a two-argument predicate.
+ @raise Invalid_argument if the two arrays have different lengths.
+ @since 4.11.0 *)
+
+val exists2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool
+(** Same as {!ArrayLabels.exists}, but for a two-argument predicate.
+ @raise Invalid_argument if the two arrays have different lengths.
+ @since 4.11.0 *)
+
val mem : 'a -> set:'a array -> bool
(** [mem x ~set] is true if and only if [x] is equal
to an element of [set].
Bigarray [a]. The first dimension corresponds to [n = 0];
the second dimension corresponds to [n = 1]; the last dimension,
to [n = Genarray.num_dims a - 1].
- Raise [Invalid_argument] if [n] is less than 0 or greater or equal than
+ @raise Invalid_argument if [n] is less than 0 or greater or equal than
[Genarray.num_dims a]. *)
external kind: ('a, 'b, 'c) t -> ('a, 'b) kind = "caml_ba_kind"
and strictly less than the corresponding dimensions of [a].
If [a] has Fortran layout, the coordinates must be greater or equal
than 1 and less or equal than the corresponding dimensions of [a].
- Raise [Invalid_argument] if the array [a] does not have exactly [N]
- dimensions, or if the coordinates are outside the array bounds.
If [N > 3], alternate syntax is provided: you can write
[a.{i1, i2, ..., iN}] instead of [Genarray.get a [|i1; ...; iN|]].
(The syntax [a.{...}] with one, two or three coordinates is
reserved for accessing one-, two- and three-dimensional arrays
- as described below.) *)
+ as described below.)
+
+ @raise Invalid_argument if the array [a] does not have exactly [N]
+ dimensions, or if the coordinates are outside the array bounds.
+ *)
external set: ('a, 'b, 'c) t -> int array -> 'a -> unit
= "caml_ba_set_generic"
array [a].
[Genarray.sub_left] applies only to Bigarrays in C layout.
- Raise [Invalid_argument] if [ofs] and [len] do not designate
+ @raise Invalid_argument if [ofs] and [len] do not designate
a valid sub-array of [a], that is, if [ofs < 0], or [len < 0],
or [ofs + len > Genarray.nth_dim a 0]. *)
array [a].
[Genarray.sub_right] applies only to Bigarrays in Fortran layout.
- Raise [Invalid_argument] if [ofs] and [len] do not designate
+ @raise Invalid_argument if [ofs] and [len] do not designate
a valid sub-array of [a], that is, if [ofs < 1], or [len < 0],
or [ofs + len > Genarray.nth_dim a (Genarray.num_dims a - 1)]. *)
the original array share the same storage space.
[Genarray.slice_left] applies only to Bigarrays in C layout.
- Raise [Invalid_argument] if [M >= N], or if [[|i1; ... ; iM|]]
+ @raise Invalid_argument if [M >= N], or if [[|i1; ... ; iM|]]
is outside the bounds of [a]. *)
external slice_right:
the original array share the same storage space.
[Genarray.slice_right] applies only to Bigarrays in Fortran layout.
- Raise [Invalid_argument] if [M >= N], or if [[|i1; ... ; iM|]]
+ @raise Invalid_argument if [M >= N], or if [[|i1; ... ; iM|]]
is outside the bounds of [a]. *)
external blit: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit
val array0_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array0.t
(** Return the zero-dimensional Bigarray corresponding to the given
- generic Bigarray. Raise [Invalid_argument] if the generic Bigarray
+ generic Bigarray.
+ @raise Invalid_argument if the generic Bigarray
does not have exactly zero dimension.
@since 4.05.0 *)
val array1_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array1.t
(** Return the one-dimensional Bigarray corresponding to the given
- generic Bigarray. Raise [Invalid_argument] if the generic Bigarray
+ generic Bigarray.
+ @raise Invalid_argument if the generic Bigarray
does not have exactly one dimension. *)
val array2_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array2.t
(** Return the two-dimensional Bigarray corresponding to the given
- generic Bigarray. Raise [Invalid_argument] if the generic Bigarray
+ generic Bigarray.
+ @raise Invalid_argument if the generic Bigarray
does not have exactly two dimensions. *)
val array3_of_genarray : ('a, 'b, 'c) Genarray.t -> ('a, 'b, 'c) Array3.t
(** Return the three-dimensional Bigarray corresponding to the given
- generic Bigarray. Raise [Invalid_argument] if the generic Bigarray
+ generic Bigarray.
+ @raise Invalid_argument if the generic Bigarray
does not have exactly three dimensions. *)
external ( || ) : bool -> bool -> bool = "%sequor"
let equal : bool -> bool -> bool = ( = )
let compare : bool -> bool -> int = Stdlib.compare
-let to_int = function false -> 0 | true -> 1
+external to_int : bool -> int = "%identity"
let to_float = function false -> 0. | true -> 1.
(*
val sub : t -> int -> int -> string
(** [Buffer.sub b off len] returns a copy of [len] bytes from the
current contents of the buffer [b], starting at offset [off].
-
- Raise [Invalid_argument] if [srcoff] and [len] do not designate a valid
+ @raise Invalid_argument if [srcoff] and [len] do not designate a valid
range of [b]. *)
val blit : t -> int -> bytes -> int -> int -> unit
(** [Buffer.blit src srcoff dst dstoff len] copies [len] characters from
the current contents of the buffer [src], starting at offset [srcoff]
to [dst], starting at character [dstoff].
-
- Raise [Invalid_argument] if [srcoff] and [len] do not designate a valid
+ @raise Invalid_argument if [srcoff] and [len] do not designate a valid
range of [src], or if [dstoff] and [len] do not designate a valid
range of [dst].
@since 3.11.2
*)
val nth : t -> int -> char
-(** Get the n-th character of the buffer. Raise [Invalid_argument] if
+(** Get the n-th character of the buffer.
+ @raise Invalid_argument if
index out of bounds *)
val length : t -> int
matching parentheses or curly brackets.
An escaped [$] character is a [$] that immediately follows a backslash
character; it then stands for a plain [$].
- Raise [Not_found] if the closing character of a parenthesized variable
+ @raise Not_found if the closing character of a parenthesized variable
cannot be found. *)
val add_buffer : t -> t -> unit
val add_channel : t -> in_channel -> int -> unit
(** [add_channel b ic n] reads at most [n] characters from the
input channel [ic] and stores them at the end of buffer [b].
- Raise [End_of_file] if the channel contains fewer than [n]
+ @raise End_of_file if the channel contains fewer than [n]
characters. In this case, the characters are still added to
the buffer, so as to avoid loss of data. *)
val truncate : t -> int -> unit
(** [truncate b len] truncates the length of [b] to [len]
Note: the internal byte sequence is not shortened.
- Raise [Invalid_argument] if [len < 0] or [len > length b].
+ @raise Invalid_argument if [len < 0] or [len > length b].
@since 4.05.0 *)
(** {1 Iterators} *)
external get : bytes -> int -> char = "%bytes_safe_get"
(** [get s n] returns the byte at index [n] in argument [s].
-
- Raise [Invalid_argument] if [n] is not a valid index in [s]. *)
+ @raise Invalid_argument if [n] is not a valid index in [s]. *)
external set : bytes -> int -> char -> unit = "%bytes_safe_set"
(** [set s n c] modifies [s] in place, replacing the byte at index [n]
with [c].
-
- Raise [Invalid_argument] if [n] is not a valid index in [s]. *)
+ @raise Invalid_argument if [n] is not a valid index in [s]. *)
external create : int -> bytes = "caml_create_bytes"
(** [create n] returns a new byte sequence of length [n]. The
sequence is uninitialized and contains arbitrary bytes.
-
- Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *)
+ @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. *)
val make : int -> char -> bytes
(** [make n c] returns a new byte sequence of length [n], filled with
the byte [c].
-
- Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *)
+ @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. *)
val init : int -> (int -> char) -> bytes
(** [Bytes.init n f] returns a fresh byte sequence of length [n], with
character [i] initialized to the result of [f i] (in increasing
index order).
-
- Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *)
+ @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. *)
val empty : bytes
(** A byte sequence of size 0. *)
(** [sub s start len] returns a new byte sequence of length [len],
containing the subsequence of [s] that starts at position [start]
and has length [len].
-
- Raise [Invalid_argument] if [start] and [len] do not designate a
+ @raise Invalid_argument if [start] and [len] do not designate a
valid range of [s]. *)
val sub_string : bytes -> int -> int -> string
[right] uninitialized bytes appended to it. If [left] or [right]
is negative, then bytes are removed (instead of appended) from
the corresponding side of [s].
-
- Raise [Invalid_argument] if the result length is negative or
+ @raise Invalid_argument if the result length is negative or
longer than {!Sys.max_string_length} bytes. *)
val fill : bytes -> int -> int -> char -> unit
(** [fill s start len c] modifies [s] in place, replacing [len]
characters with [c], starting at [start].
-
- Raise [Invalid_argument] if [start] and [len] do not designate a
+ @raise Invalid_argument if [start] and [len] do not designate a
valid range of [s]. *)
val blit : bytes -> int -> bytes -> int -> int -> unit
index [dstoff]. It works correctly even if [src] and [dst] are the
same byte sequence, and the source and destination intervals
overlap.
-
- Raise [Invalid_argument] if [srcoff] and [len] do not
+ @raise Invalid_argument if [srcoff] and [len] do not
designate a valid range of [src], or if [dstoff] and [len]
do not designate a valid range of [dst]. *)
(** [blit_string src srcoff dst dstoff len] copies [len] bytes from
string [src], starting at index [srcoff], to byte sequence [dst],
starting at index [dstoff].
-
- Raise [Invalid_argument] if [srcoff] and [len] do not
+ @raise Invalid_argument if [srcoff] and [len] do not
designate a valid range of [src], or if [dstoff] and [len]
do not designate a valid range of [dst]. *)
(** [concat sep sl] concatenates the list of byte sequences [sl],
inserting the separator byte sequence [sep] between each, and
returns the result as a new byte sequence.
-
- Raise [Invalid_argument] if the result is longer than
+ @raise Invalid_argument if the result is longer than
{!Sys.max_string_length} bytes. *)
val cat : bytes -> bytes -> bytes
(** [cat s1 s2] concatenates [s1] and [s2] and returns the result
- as new byte sequence.
-
- Raise [Invalid_argument] if the result is longer than
+ as a new byte sequence.
+ @raise Invalid_argument if the result is longer than
{!Sys.max_string_length} bytes. *)
val iter : (char -> unit) -> bytes -> unit
by escape sequences, following the lexical conventions of OCaml.
All characters outside the ASCII printable range (32..126) are
escaped, as well as backslash and double-quote.
-
- Raise [Invalid_argument] if the result is longer than
+ @raise Invalid_argument if the result is longer than
{!Sys.max_string_length} bytes. *)
val index : bytes -> char -> int
(** [index s c] returns the index of the first occurrence of byte [c]
in [s].
-
- Raise [Not_found] if [c] does not occur in [s]. *)
+ @raise Not_found if [c] does not occur in [s]. *)
val index_opt: bytes -> char -> int option
(** [index_opt s c] returns the index of the first occurrence of byte [c]
val rindex : bytes -> char -> int
(** [rindex s c] returns the index of the last occurrence of byte [c]
in [s].
-
- Raise [Not_found] if [c] does not occur in [s]. *)
+ @raise Not_found if [c] does not occur in [s]. *)
val rindex_opt: bytes -> char -> int option
(** [rindex_opt s c] returns the index of the last occurrence of byte [c]
(** [index_from s i c] returns the index of the first occurrence of
byte [c] in [s] after position [i]. [Bytes.index s c] is
equivalent to [Bytes.index_from s 0 c].
-
- Raise [Invalid_argument] if [i] is not a valid position in [s].
- Raise [Not_found] if [c] does not occur in [s] after position [i]. *)
+ @raise Invalid_argument if [i] is not a valid position in [s].
+ @raise Not_found if [c] does not occur in [s] after position [i]. *)
val index_from_opt: bytes -> int -> char -> int option
(** [index_from_opt s i c] returns the index of the first occurrence of
byte [c] in [s] after position [i] or [None] if [c] does not occur in [s]
after position [i].
[Bytes.index_opt s c] is equivalent to [Bytes.index_from_opt s 0 c].
-
- Raise [Invalid_argument] if [i] is not a valid position in [s].
+ @raise Invalid_argument if [i] is not a valid position in [s].
@since 4.05 *)
val rindex_from : bytes -> int -> char -> int
(** [rindex_from s i c] returns the index of the last occurrence of
byte [c] in [s] before position [i+1]. [rindex s c] is equivalent
to [rindex_from s (Bytes.length s - 1) c].
-
- Raise [Invalid_argument] if [i+1] is not a valid position in [s].
- Raise [Not_found] if [c] does not occur in [s] before position [i+1]. *)
+ @raise Invalid_argument if [i+1] is not a valid position in [s].
+ @raise Not_found if [c] does not occur in [s] before position [i+1]. *)
val rindex_from_opt: bytes -> int -> char -> int option
(** [rindex_from_opt s i c] returns the index of the last occurrence
of byte [c] in [s] before position [i+1] or [None] if [c] does not
occur in [s] before position [i+1]. [rindex_opt s c] is equivalent to
[rindex_from s (Bytes.length s - 1) c].
-
- Raise [Invalid_argument] if [i+1] is not a valid position in [s].
+ @raise Invalid_argument if [i+1] is not a valid position in [s].
@since 4.05 *)
val contains : bytes -> char -> bool
(** [contains_from s start c] tests if byte [c] appears in [s] after
position [start]. [contains s c] is equivalent to [contains_from
s 0 c].
-
- Raise [Invalid_argument] if [start] is not a valid position in [s]. *)
+ @raise Invalid_argument if [start] is not a valid position in [s]. *)
val rcontains_from : bytes -> int -> char -> bool
(** [rcontains_from s stop c] tests if byte [c] appears in [s] before
position [stop+1].
-
- Raise [Invalid_argument] if [stop < 0] or [stop+1] is not a valid
+ @raise Invalid_argument if [stop < 0] or [stop+1] is not a valid
position in [s]. *)
val uppercase : bytes -> bytes
external get : bytes -> int -> char = "%bytes_safe_get"
(** [get s n] returns the byte at index [n] in argument [s].
-
- Raise [Invalid_argument] if [n] is not a valid index in [s]. *)
+ @raise Invalid_argument if [n] is not a valid index in [s]. *)
external set : bytes -> int -> char -> unit = "%bytes_safe_set"
(** [set s n c] modifies [s] in place, replacing the byte at index [n]
with [c].
-
- Raise [Invalid_argument] if [n] is not a valid index in [s]. *)
+ @raise Invalid_argument if [n] is not a valid index in [s]. *)
external create : int -> bytes = "caml_create_bytes"
(** [create n] returns a new byte sequence of length [n]. The
sequence is uninitialized and contains arbitrary bytes.
-
- Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *)
+ @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. *)
val make : int -> char -> bytes
(** [make n c] returns a new byte sequence of length [n], filled with
the byte [c].
-
- Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *)
+ @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. *)
val init : int -> f:(int -> char) -> bytes
(** [init n f] returns a fresh byte sequence of length [n],
with character [i] initialized to the result of [f i].
-
- Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *)
+ @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. *)
val empty : bytes
(** A byte sequence of size 0. *)
(** [sub s start len] returns a new byte sequence of length [len],
containing the subsequence of [s] that starts at position [start]
and has length [len].
-
- Raise [Invalid_argument] if [start] and [len] do not designate a
+ @raise Invalid_argument if [start] and [len] do not designate a
valid range of [s]. *)
val sub_string : bytes -> pos:int -> len:int -> string
[right] uninitialized bytes appended to it. If [left] or [right]
is negative, then bytes are removed (instead of appended) from
the corresponding side of [s].
-
- Raise [Invalid_argument] if the result length is negative or
+ @raise Invalid_argument if the result length is negative or
longer than {!Sys.max_string_length} bytes.
@since 4.05.0 *)
val fill : bytes -> pos:int -> len:int -> char -> unit
(** [fill s start len c] modifies [s] in place, replacing [len]
characters with [c], starting at [start].
-
- Raise [Invalid_argument] if [start] and [len] do not designate a
+ @raise Invalid_argument if [start] and [len] do not designate a
valid range of [s]. *)
val blit :
index [dstoff]. It works correctly even if [src] and [dst] are the
same byte sequence, and the source and destination intervals
overlap.
-
- Raise [Invalid_argument] if [srcoff] and [len] do not
+ @raise Invalid_argument if [srcoff] and [len] do not
designate a valid range of [src], or if [dstoff] and [len]
do not designate a valid range of [dst]. *)
(** [blit src srcoff dst dstoff len] copies [len] bytes from string
[src], starting at index [srcoff], to byte sequence [dst],
starting at index [dstoff].
-
- Raise [Invalid_argument] if [srcoff] and [len] do not
+ @raise Invalid_argument if [srcoff] and [len] do not
designate a valid range of [src], or if [dstoff] and [len]
do not designate a valid range of [dst].
@since 4.05.0 *)
val cat : bytes -> bytes -> bytes
(** [cat s1 s2] concatenates [s1] and [s2] and returns the result
- as new byte sequence.
-
- Raise [Invalid_argument] if the result is longer than
+ as new byte sequence.
+ @raise Invalid_argument if the result is longer than
{!Sys.max_string_length} bytes.
@since 4.05.0 *)
val index : bytes -> char -> int
(** [index s c] returns the index of the first occurrence of byte [c]
in [s].
-
- Raise [Not_found] if [c] does not occur in [s]. *)
+ @raise Not_found if [c] does not occur in [s]. *)
val index_opt: bytes -> char -> int option
(** [index_opt s c] returns the index of the first occurrence of byte [c]
val rindex : bytes -> char -> int
(** [rindex s c] returns the index of the last occurrence of byte [c]
in [s].
-
- Raise [Not_found] if [c] does not occur in [s]. *)
+ @raise Not_found if [c] does not occur in [s]. *)
val rindex_opt: bytes -> char -> int option
(** [rindex_opt s c] returns the index of the last occurrence of byte [c]
(** [index_from s i c] returns the index of the first occurrence of
byte [c] in [s] after position [i]. [Bytes.index s c] is
equivalent to [Bytes.index_from s 0 c].
-
- Raise [Invalid_argument] if [i] is not a valid position in [s].
- Raise [Not_found] if [c] does not occur in [s] after position [i]. *)
+ @raise Invalid_argument if [i] is not a valid position in [s].
+ @raise Not_found if [c] does not occur in [s] after position [i]. *)
val index_from_opt: bytes -> int -> char -> int option
(** [index_from _opts i c] returns the index of the first occurrence of
byte [c] in [s] after position [i] or [None] if [c] does not occur in [s]
after position [i].
[Bytes.index_opt s c] is equivalent to [Bytes.index_from_opt s 0 c].
-
- Raise [Invalid_argument] if [i] is not a valid position in [s].
+ @raise Invalid_argument if [i] is not a valid position in [s].
@since 4.05 *)
val rindex_from : bytes -> int -> char -> int
(** [rindex_from s i c] returns the index of the last occurrence of
byte [c] in [s] before position [i+1]. [rindex s c] is equivalent
to [rindex_from s (Bytes.length s - 1) c].
-
- Raise [Invalid_argument] if [i+1] is not a valid position in [s].
- Raise [Not_found] if [c] does not occur in [s] before position [i+1]. *)
+ @raise Invalid_argument if [i+1] is not a valid position in [s].
+ @raise Not_found if [c] does not occur in [s] before position [i+1]. *)
val rindex_from_opt: bytes -> int -> char -> int option
(** [rindex_from_opt s i c] returns the index of the last occurrence
of byte [c] in [s] before position [i+1] or [None] if [c] does not
occur in [s] before position [i+1]. [rindex_opt s c] is equivalent to
[rindex_from s (Bytes.length s - 1) c].
-
- Raise [Invalid_argument] if [i+1] is not a valid position in [s].
+ @raise Invalid_argument if [i+1] is not a valid position in [s].
@since 4.05 *)
val contains : bytes -> char -> bool
(** [contains_from s start c] tests if byte [c] appears in [s] after
position [start]. [contains s c] is equivalent to [contains_from
s 0 c].
-
- Raise [Invalid_argument] if [start] is not a valid position in [s]. *)
+ @raise Invalid_argument if [start] is not a valid position in [s]. *)
val rcontains_from : bytes -> int -> char -> bool
(** [rcontains_from s stop c] tests if byte [c] appears in [s] before
position [stop+1].
-
- Raise [Invalid_argument] if [stop < 0] or [stop+1] is not a valid
+ @raise Invalid_argument if [stop < 0] or [stop+1] is not a valid
position in [s]. *)
val uppercase : bytes -> bytes
let rec update_mod shape o n =
match shape with
| Function ->
- (* The optimisation below is invalid on bytecode since
- the RESTART instruction checks the length of closures.
- See PR#4008 *)
- if Sys.backend_type = Sys.Native
- && Obj.tag n = Obj.closure_tag
- && Obj.size n <= Obj.size o
+ (* In bytecode, the RESTART instruction checks the size of closures.
+ Hence, the optimized case [overwrite o n] is valid only if [o] and
+ [n] have the same size. (See PR#4008.)
+ In native code, the size of closures does not matter, so overwriting
+ is possible so long as the size of [n] is no greater than that of [o].
+ *)
+ if Obj.tag n = Obj.closure_tag
+ && (Obj.size n = Obj.size o
+ || (Sys.backend_type = Sys.Native
+ && Obj.size n <= Obj.size o))
then begin overwrite o n end
else overwrite o (Obj.repr (fun x -> (Obj.obj n : _ -> _) x))
| Lazy ->
bytes_unsafe_set s 3 (unsafe_chr (48 + n mod 10));
unsafe_to_string s
-let lowercase c =
- if (c >= 'A' && c <= 'Z')
- || (c >= '\192' && c <= '\214')
- || (c >= '\216' && c <= '\222')
- then unsafe_chr(code c + 32)
- else c
+let lowercase = function
+ | 'A' .. 'Z'
+ | '\192' .. '\214'
+ | '\216' .. '\222' as c ->
+ unsafe_chr(code c + 32)
+ | c -> c
-let uppercase c =
- if (c >= 'a' && c <= 'z')
- || (c >= '\224' && c <= '\246')
- || (c >= '\248' && c <= '\254')
- then unsafe_chr(code c - 32)
- else c
+let uppercase = function
+ | 'a' .. 'z'
+ | '\224' .. '\246'
+ | '\248' .. '\254' as c ->
+ unsafe_chr(code c - 32)
+ | c -> c
-let lowercase_ascii c =
- if (c >= 'A' && c <= 'Z')
- then unsafe_chr(code c + 32)
- else c
+let lowercase_ascii = function
+ | 'A' .. 'Z' as c -> unsafe_chr(code c + 32)
+ | c -> c
-let uppercase_ascii c =
- if (c >= 'a' && c <= 'z')
- then unsafe_chr(code c - 32)
- else c
+let uppercase_ascii = function
+ | 'a' .. 'z' as c -> unsafe_chr(code c - 32)
+ | c -> c
type t = char
val chr : int -> char
(** Return the character with the given ASCII code.
- Raise [Invalid_argument "Char.chr"] if the argument is
+ @raise Invalid_argument if the argument is
outside the range 0--255. *)
val escaped : char -> string
val to_hex : t -> string
(** Return the printable hexadecimal representation of the given digest.
- Raise [Invalid_argument] if the argument is not exactly 16 bytes.
+ @raise Invalid_argument if the argument is not exactly 16 bytes.
*)
val from_hex : string -> t
(** Convert a hexadecimal representation back into the corresponding digest.
- Raise [Invalid_argument] if the argument is not exactly 32 hexadecimal
+ @raise Invalid_argument if the argument is not exactly 32 hexadecimal
characters.
@since 4.00.0 *)
(* *)
(**************************************************************************)
-(** Ephemerons and weak hash table *)
+(** Ephemerons and weak hash tables *)
-(** Ephemerons and weak hash table are useful when one wants to cache
+(** Ephemerons and weak hash tables are useful when one wants to cache
or memorize the computation of a function, as long as the
arguments and the function are used, without creating memory leaks
by continuously keeping old computation results that are not
useful anymore because one argument or the function is freed. An
implementation using {!Hashtbl.t} is not suitable because all
- associations would keep in memory the arguments and the result.
+ associations would keep the arguments and the result in memory.
Ephemerons can also be used for "adding" a field to an arbitrary
- boxed ocaml value: you can attach an information to a value
+ boxed OCaml value: you can attach some information to a value
created by an external library without memory leaks.
Ephemerons hold some keys and one or no data. They are all boxed
- ocaml values. The keys of an ephemeron have the same behavior
- than weak pointers according to the garbage collector. In fact
- ocaml weak pointers are implemented as ephemerons without data.
+ OCaml values. The keys of an ephemeron have the same behavior
+ as weak pointers according to the garbage collector. In fact
+ OCaml weak pointers are implemented as ephemerons without data.
The keys and data of an ephemeron are said to be full if they
- point to a value, empty if the value have never been set, have
+ point to a value, or empty if the value has never been set, has
been unset, or was erased by the GC. In the function that accesses
the keys or data these two states are represented by the [option]
type.
{!Marshal} module.
Ephemerons are defined in a language agnostic way in this paper:
- B. Hayes, Ephemerons: a New Finalization Mechanism, OOPSLA'9
+ B. Hayes, Ephemerons: A New Finalization Mechanism, OOPSLA'97
@since 4.03.0
*)
(readable and writable only by the file owner). The file is
guaranteed to be different from any other file that existed when
[temp_file] was called.
- Raise [Sys_error] if the file could not be created.
+ @raise Sys_error if the file could not be created.
@before 3.11.2 no ?temp_dir optional argument
*)
if any are quoted using {!Filename.quote}, then concatenated.
Under Win32, additional quoting is performed as required by the
[cmd.exe] shell that is called by {!Sys.command}.
-
- Raise [Failure] if the command cannot be escaped on the current platform.
+ @raise Failure if the command cannot be escaped on the current platform.
*)
and is ignored.
Depending on the execution platforms, other representations of
floating-point numbers can be accepted, but should not be relied upon.
- Raise [Failure "float_of_string"] if the given string is not a valid
+ @raise Failure if the given string is not a valid
representation of a float. *)
val of_string_opt: string -> float option
val get : t -> int -> float
(** [get a n] returns the element number [n] of floatarray [a].
-
- Raise [Invalid_argument] if [n] is outside the range 0 to
+ @raise Invalid_argument if [n] is outside the range 0 to
[(length a - 1)]. *)
val set : t -> int -> float -> unit
(** [set a n x] modifies floatarray [a] in place, replacing element
number [n] with [x].
-
- Raise [Invalid_argument] if [n] is outside the range 0 to
+ @raise Invalid_argument if [n] is outside the range 0 to
[(length a - 1)]. *)
val make : int -> float -> t
(** [make n x] returns a fresh floatarray of length [n], initialized with [x].
-
- Raise [Invalid_argument] if [n < 0] or [n > Sys.max_floatarray_length]. *)
+ @raise Invalid_argument if [n < 0] or [n > Sys.max_floatarray_length]. *)
val create : int -> t
(** [create n] returns a fresh floatarray of length [n],
with uninitialized data.
-
- Raise [Invalid_argument] if [n < 0] or [n > Sys.max_floatarray_length]. *)
+ @raise Invalid_argument if [n < 0] or [n > Sys.max_floatarray_length]. *)
val init : int -> (int -> float) -> t
(** [init n f] returns a fresh floatarray of length [n],
- with element number [i] initialized to the result of [f i].
- In other terms, [init n f] tabulates the results of [f]
- applied to the integers [0] to [n-1].
-
- Raise [Invalid_argument] if [n < 0] or [n > Sys.max_floatarray_length]. *)
+ with element number [i] initialized to the result of [f i].
+ In other terms, [init n f] tabulates the results of [f]
+ applied to the integers [0] to [n-1].
+ @raise Invalid_argument if [n < 0] or [n > Sys.max_floatarray_length]. *)
val append : t -> t -> t
(** [append v1 v2] returns a fresh floatarray containing the
- concatenation of the floatarrays [v1] and [v2].
-
- Raise [Invalid_argument] if
- [length v1 + length v2 > Sys.max_floatarray_length]. *)
+ concatenation of the floatarrays [v1] and [v2].
+ @raise Invalid_argument if
+ [length v1 + length v2 > Sys.max_floatarray_length]. *)
val concat : t list -> t
(** Same as {!append}, but concatenates a list of floatarrays. *)
val sub : t -> int -> int -> t
(** [sub a start len] returns a fresh floatarray of length [len],
- containing the elements number [start] to [start + len - 1]
- of floatarray [a].
-
- Raise [Invalid_argument] if [start] and [len] do not
- designate a valid subarray of [a]; that is, if
- [start < 0], or [len < 0], or [start + len > length a]. *)
+ containing the elements number [start] to [start + len - 1]
+ of floatarray [a].
+ @raise Invalid_argument if [start] and [len] do not
+ designate a valid subarray of [a]; that is, if
+ [start < 0], or [len < 0], or [start + len > length a]. *)
val copy : t -> t
(** [copy a] returns a copy of [a], that is, a fresh floatarray
val fill : t -> int -> int -> float -> unit
(** [fill a ofs len x] modifies the floatarray [a] in place,
- storing [x] in elements number [ofs] to [ofs + len - 1].
-
- Raise [Invalid_argument] if [ofs] and [len] do not
- designate a valid subarray of [a]. *)
+ storing [x] in elements number [ofs] to [ofs + len - 1].
+ @raise Invalid_argument if [ofs] and [len] do not
+ designate a valid subarray of [a]. *)
val blit : t -> int -> t -> int -> int -> unit
(** [blit v1 o1 v2 o2 len] copies [len] elements
starting at element number [o2]. It works correctly even if
[v1] and [v2] are the same floatarray, and the source and
destination chunks overlap.
-
- Raise [Invalid_argument] if [o1] and [len] do not
+ @raise Invalid_argument if [o1] and [len] do not
designate a valid subarray of [v1], or if [o2] and [len] do not
designate a valid subarray of [v2]. *)
val of_list : float list -> t
(** [of_list l] returns a fresh floatarray containing the elements
of [l].
-
- Raise [Invalid_argument] if the length of [l] is greater than
+ @raise Invalid_argument if the length of [l] is greater than
[Sys.max_floatarray_length].*)
(** {2 Iterators} *)
val iter2 : (float -> float -> unit) -> t -> t -> unit
(** [Array.iter2 f a b] applies function [f] to all the elements of [a]
and [b].
- Raise [Invalid_argument] if the floatarrays are not the same size. *)
+ @raise Invalid_argument if the floatarrays are not the same size. *)
val map2 : (float -> float -> float) -> t -> t -> t
(** [map2 f a b] applies function [f] to all the elements of [a]
and [b], and builds a floatarray with the results returned by [f]:
[[| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|]].
- Raise [Invalid_argument] if the floatarrays are not the same size. *)
+ @raise Invalid_argument if the floatarrays are not the same size. *)
(** {2 Array scanning} *)
(** Geometry functions and types *)
type geometry = { max_indent:int; margin: int}
+let validate_geometry {margin; max_indent} =
+ if max_indent < 2 then
+ Error "max_indent < 2"
+ else if margin <= max_indent then
+ Error "margin <= max_indent"
+ else Ok ()
+
let check_geometry geometry =
- geometry.max_indent > 1
- && geometry.margin > geometry.max_indent
+ match validate_geometry geometry with
+ | Ok () -> true
+ | Error _ -> false
let pp_get_margin state () = state.pp_margin
+let pp_set_full_geometry state {margin; max_indent} =
+ pp_set_margin state margin;
+ pp_set_max_indent state max_indent;
+ ()
+
let pp_set_geometry state ~max_indent ~margin =
- if max_indent < 2 then
- raise (Invalid_argument "Format.pp_set_geometry: max_indent < 2")
- else if margin <= max_indent then
- raise (Invalid_argument "Format.pp_set_geometry: margin <= max_indent")
- else
- pp_set_margin state margin; pp_set_max_indent state max_indent
+ let geometry = { max_indent; margin } in
+ match validate_geometry geometry with
+ | Error msg ->
+ raise (Invalid_argument ("Format.pp_set_geometry: " ^ msg))
+ | Ok () ->
+ pp_set_full_geometry state geometry
let pp_safe_set_geometry state ~max_indent ~margin =
- if check_geometry {max_indent;margin} then
- pp_set_geometry state ~max_indent ~margin
- else
- ()
+ let geometry = { max_indent; margin } in
+ match validate_geometry geometry with
+ | Error _msg ->
+ ()
+ | Ok () ->
+ pp_set_full_geometry state geometry
let pp_get_geometry state () =
{ margin = pp_get_margin state (); max_indent = pp_get_max_indent state () }
+let pp_update_geometry state update =
+ let geometry = pp_get_geometry state () in
+ pp_set_full_geometry state (update geometry)
+
(* Setting a formatter basic output functions. *)
let pp_set_formatter_out_functions state {
out_string = f;
and set_geometry = pp_set_geometry std_formatter
and safe_set_geometry = pp_safe_set_geometry std_formatter
and get_geometry = pp_get_geometry std_formatter
+and update_geometry = pp_update_geometry std_formatter
and set_max_boxes = pp_set_max_boxes std_formatter
and get_max_boxes = pp_get_max_boxes std_formatter
not rule the policy of inner boxes. For instance, if a vertical box is
nested in an horizontal box, all break hints within the vertical box will
split the line.
+
+ Moreover, opening a box after the {{!maxindent}maximum indentation limit}
+ splits the line whether or not the box would end up fitting on the line.
+
*)
val pp_open_box : formatter -> int -> unit
A break hint splits the line if there is no more room on the line to
print the remainder of the box.
- Within this box, the pretty-printer emphasizes the box structure: a break
+ Within this box, the pretty-printer emphasizes the box structure:
+ if a structural box does not fit fully on a simple line, a break
hint also splits the line if the splitting ``moves to the left''
(i.e. the new line gets an indentation smaller than the one of the current
line).
(** [pp_set_margin ppf d] sets the right margin to [d] (in characters):
the pretty-printer splits lines that overflow the right margin according to
the break hints given.
+ Setting the margin to [d] means that the formatting engine aims at
+ printing at most [d-1] characters per line.
Nothing happens if [d] is smaller than 2.
If [d] is too large, the right margin is set to the maximum
admissible value (which is greater than [10 ^ 9]).
val get_margin : unit -> int
(** Returns the position of the right margin. *)
-(** {1 Maximum indentation limit} *)
+(** {1:maxindent Maximum indentation limit} *)
val pp_set_max_indent : formatter -> int -> unit
val set_max_indent : int -> unit
["123456789"] and ["123456789A"] .
Note also that vertical boxes never fit on a line whereas horizontal boxes
always fully fit on the current line.
+ Opening a box may split a line whereas the contents may have fit.
+ If this behavior is problematic, it can be curtailed by setting the maximum
+ indentation limit to [margin - 1]. Note that setting the maximum indentation
+ limit to [margin] is invalid.
Nothing happens if [d] is smaller than 2.
@since 4.08.0
*)
+(**
+ [pp_update_geometry ppf (fun geo -> { geo with ... })] lets you
+ update a formatter's geometry in a way that is robust to extension
+ of the [geometry] record with new fields.
+
+ Raises an invalid argument exception if the returned geometry
+ does not satisfy {!check_geometry}.
+
+ @since 4.11.0
+*)
+val pp_update_geometry : formatter -> (geometry -> geometry) -> unit
+val update_geometry : (geometry -> geometry) -> unit
+
val pp_get_geometry: formatter -> unit -> geometry
val get_geometry: unit -> geometry
(** Return the current geometry of the formatter
exception Finally_raised of exn
+let () = Printexc.register_printer @@ function
+| Finally_raised exn -> Some ("Fun.Finally_raised: " ^ Printexc.to_string exn)
+| _ -> None
+
let protect ~(finally : unit -> unit) work =
let finally_no_exn () =
try finally () with e ->
external get_bucket : int -> int = "caml_get_major_bucket" [@@noalloc]
external get_credit : unit -> int = "caml_get_major_credit" [@@noalloc]
external huge_fallback_count : unit -> int = "caml_gc_huge_fallback_count"
+external eventlog_pause : unit -> unit = "caml_eventlog_pause"
+external eventlog_resume : unit -> unit = "caml_eventlog_resume"
open Printf
let delete_alarm a = a := false
+
+module Memprof =
+ struct
+ type allocation =
+ { n_samples : int;
+ size : int;
+ unmarshalled : bool;
+ callstack : Printexc.raw_backtrace }
+
+ type ('minor, 'major) tracker = {
+ alloc_minor: allocation -> 'minor option;
+ alloc_major: allocation -> 'major option;
+ promote: 'minor -> 'major option;
+ dealloc_minor: 'minor -> unit;
+ dealloc_major: 'major -> unit;
+ }
+
+ let null_tracker = {
+ alloc_minor = (fun _ -> None);
+ alloc_major = (fun _ -> None);
+ promote = (fun _ -> None);
+ dealloc_minor = (fun _ -> ());
+ dealloc_major = (fun _ -> ());
+ }
+
+ external c_start :
+ float -> int -> ('minor, 'major) tracker -> unit
+ = "caml_memprof_start"
+
+ let start
+ ~sampling_rate
+ ?(callstack_size = max_int)
+ tracker =
+ c_start sampling_rate callstack_size tracker
+
+ external stop : unit -> unit = "caml_memprof_stop"
+ end
external get_bucket : int -> int = "caml_get_major_bucket" [@@noalloc]
(** [get_bucket n] returns the current size of the [n]-th future bucket
of the GC smoothing system. The unit is one millionth of a full GC.
- Raise [Invalid_argument] if [n] is negative, return 0 if n is larger
+ @raise Invalid_argument if [n] is negative, return 0 if n is larger
than the smoothing window.
@since 4.03.0 *)
val delete_alarm : alarm -> unit
(** [delete_alarm a] will stop the calls to the function associated
- to [a]. Calling [delete_alarm a] again has no effect. *)
+ to [a]. Calling [delete_alarm a] again has no effect. *)
+
+external eventlog_pause : unit -> unit = "caml_eventlog_pause"
+(** [eventlog_pause ()] will pause the collection of traces in the
+ runtime.
+ Traces are collected if the program is linked to the instrumented runtime
+ and started with the environment variable OCAML_EVENTLOG_ENABLED.
+ Events are flushed to disk after pausing, and no new events will be
+ recorded until [eventlog_resume] is called. *)
+
+external eventlog_resume : unit -> unit = "caml_eventlog_resume"
+(** [eventlog_resume ()] will resume the collection of traces in the
+ runtime.
+ Traces are collected if the program is linked to the instrumented runtime
+ and started with the environment variable OCAML_EVENTLOG_ENABLED.
+ This call can be used after calling [eventlog_pause], or if the program
+ was started with OCAML_EVENTLOG_ENABLED=p. (which pauses the collection of
+ traces before the first event.) *)
+
+
+(** [Memprof] is a sampling engine for allocated memory words. Every
+ allocated word has a probability of being sampled equal to a
+ configurable sampling rate. Once a block is sampled, it becomes
+ tracked. A tracked block triggers a user-defined callback as soon
+ as it is allocated, promoted or deallocated.
+
+ Since blocks are composed of several words, a block can potentially
+ be sampled several times. If a block is sampled several times, then
+ each of the callback is called once for each event of this block:
+ the multiplicity is given in the [n_samples] field of the
+ [allocation] structure.
+
+ This engine makes it possible to implement a low-overhead memory
+ profiler as an OCaml library.
+
+ Note: this API is EXPERIMENTAL. It may change without prior
+ notice. *)
+module Memprof :
+ sig
+ type allocation = private
+ { n_samples : int;
+ (** The number of samples in this block (>= 1). *)
+
+ size : int;
+ (** The size of the block, in words, excluding the header. *)
+
+ unmarshalled : bool;
+ (** Whether the block comes from unmarshalling. *)
+
+ callstack : Printexc.raw_backtrace
+ (** The callstack for the allocation. *)
+ }
+ (** The type of metadata associated with allocations. This is the
+ type of records passed to the callback triggered by the
+ sampling of an allocation. *)
+
+ type ('minor, 'major) tracker = {
+ alloc_minor: allocation -> 'minor option;
+ alloc_major: allocation -> 'major option;
+ promote: 'minor -> 'major option;
+ dealloc_minor: 'minor -> unit;
+ dealloc_major: 'major -> unit;
+ }
+ (**
+ A [('minor, 'major) tracker] describes how memprof should track
+ sampled blocks over their lifetime, keeping a user-defined piece
+ of metadata for each of them: ['minor] is the type of metadata
+ to keep for minor blocks, and ['major] the type of metadata
+ for major blocks.
+
+ If an allocation-tracking or promotion-tracking function returns [None],
+ memprof stops tracking the corresponding value.
+ *)
+
+ val null_tracker: ('minor, 'major) tracker
+ (** Default callbacks simply return [None] or [()] *)
+
+ val start :
+ sampling_rate:float ->
+ ?callstack_size:int ->
+ ('minor, 'major) tracker ->
+ unit
+ (** Start the sampling with the given parameters. Fails if
+ sampling is already active.
+
+ The parameter [sampling_rate] is the sampling rate in samples
+ per word (including headers). Usually, with cheap callbacks, a
+ rate of 1e-4 has no visible effect on performance, and 1e-3
+ causes the program to run a few percent slower
+
+ The parameter [callstack_size] is the length of the callstack
+ recorded at every sample. Its default is [max_int].
+
+ The parameter [tracker] determines how to track sampled blocks
+ over their lifetime in the minor and major heap.
+
+ Sampling is temporarily disabled when calling a callback
+ for the current thread. So they do not need to be reentrant if
+ the program is single-threaded. However, if threads are used,
+ it is possible that a context switch occurs during a callback,
+ in this case the callback functions must be reentrant.
+
+ Note that the callback can be postponed slightly after the
+ actual event. The callstack passed to the callback is always
+ accurate, but the program state may have evolved.
+
+ Calling [Thread.exit] in a callback is currently unsafe and can
+ result in undefined behavior. *)
+
+ val stop : unit -> unit
+ (** Stop the sampling. Fails if sampling is not active.
+
+ This function does not allocate memory, but tries to run the
+ postponed callbacks for already allocated memory blocks (of
+ course, these callbacks may allocate).
+
+ All the already tracked blocks are discarded.
+
+ Calling [stop] when a callback is running can lead to
+ callbacks not being called even though some events happened. *)
+end
(** Multiplication. *)
external div : int32 -> int32 -> int32 = "%int32_div"
-(** Integer division. Raise [Division_by_zero] if the second
- argument is zero. This division rounds the real quotient of
- its arguments towards zero, as specified for {!Stdlib.(/)}. *)
+(** Integer division. This division rounds the real quotient of
+ its arguments towards zero, as specified for {!Stdlib.(/)}.
+ @raise Division_by_zero if the second
+ argument is zero. *)
val unsigned_div : int32 -> int32 -> int32
(** Same as {!div}, except that arguments and result are interpreted as {e
The [_] (underscore) character can appear anywhere in the string
and is ignored.
- Raise [Failure "Int32.of_string"] if the given string is not
+ @raise Failure if the given string is not
a valid representation of an integer, or if the integer represented
exceeds the range of integers representable in type [int32]. *)
(** Multiplication. *)
external div : int64 -> int64 -> int64 = "%int64_div"
-(** Integer division. Raise [Division_by_zero] if the second
+(** Integer division.
+ @raise Division_by_zero if the second
argument is zero. This division rounds the real quotient of
its arguments towards zero, as specified for {!Stdlib.(/)}. *)
The [_] (underscore) character can appear anywhere in the string
and is ignored.
- Raise [Failure "Int64.of_string"] if the given string is not
+ @raise Failure if the given string is not
a valid representation of an integer, or if the integer represented
exceeds the range of integers representable in type [int64]. *)
If [x] has already been forced, [Lazy.force x] returns the
same value again without recomputing it. If it raised an exception,
the same exception is raised again.
- Raise {!Undefined} if the forcing of [x] tries to force [x] itself
+ @raise Undefined if the forcing of [x] tries to force [x] itself
recursively.
*)
(** [force_val x] forces the suspension [x] and returns its
result. If [x] has already been forced, [force_val x]
returns the same value again without recomputing it.
- Raise {!Undefined} if the forcing of [x] tries to force [x] itself
- recursively.
+
If the computation of [x] raises an exception, it is unspecified
whether [force_val x] raises the same exception or {!Undefined}.
+ @raise Undefined if the forcing of [x] tries to force [x] itself
+ recursively.
*)
val from_fun : (unit -> 'a) -> 'a t
lex_curr_p = if with_positions then zero_pos else dummy_pos;
}
+let set_position lexbuf position =
+ lexbuf.lex_curr_p <- {position with pos_fname = lexbuf.lex_curr_p.pos_fname};
+ lexbuf.lex_abs_pos <- position.pos_cnum
+
+let set_filename lexbuf fname =
+ lexbuf.lex_curr_p <- {lexbuf.lex_curr_p with pos_fname = fname}
+
let with_positions lexbuf = lexbuf.lex_curr_p != dummy_pos
let lexeme lexbuf =
starting at index 0, and return the number of bytes
provided. A return value of 0 means end of input. *)
+val set_position : lexbuf -> position -> unit
+(** Set the initial tracked input position for [lexbuf] to a custom value.
+ Ignores [pos_fname]. See {!set_filename} for changing this field.
+ @since 4.11 *)
+
+val set_filename: lexbuf -> string -> unit
+(** Set filename in the initial tracked position to [file] in
+ [lexbuf].
+ @since 4.11 *)
+
val with_positions : lexbuf -> bool
(** Tell whether the lexer buffer keeps track of position fields
[lex_curr_p] / [lex_start_p], as determined by the corresponding
let filter = find_all
+let filteri p l =
+ let rec aux i acc = function
+ | [] -> rev acc
+ | x::l -> aux (i + 1) (if p i x then x::acc else acc) l
+ in
+ aux 0 [] l
+
let filter_map f =
let rec aux accu = function
| [] -> rev accu
aux f (rev_append xs acc) l
in aux f [] l
+let fold_left_map f accu l =
+ let rec aux accu l_accu = function
+ | [] -> accu, rev l_accu
+ | x :: l ->
+ let accu, x = f accu x in
+ aux accu (x :: l_accu) l in
+ aux accu [] l
+
let partition p l =
let rec part yes no = function
| [] -> (rev yes, rev no)
*)
val hd : 'a list -> 'a
-(** Return the first element of the given list. Raise
- [Failure "hd"] if the list is empty. *)
+(** Return the first element of the given list.
+ @raise Failure if the list is empty. *)
val tl : 'a list -> 'a list
-(** Return the given list without its first element. Raise
- [Failure "tl"] if the list is empty. *)
+(** Return the given list without its first element.
+ @raise Failure if the list is empty. *)
val nth: 'a list -> int -> 'a
(** Return the [n]-th element of the given list.
The first element (head of the list) is at position 0.
- Raise [Failure "nth"] if the list is too short.
- Raise [Invalid_argument "List.nth"] if [n] is negative. *)
+ @raise Failure if the list is too short.
+ @raise Invalid_argument if [n] is negative. *)
val nth_opt: 'a list -> int -> 'a option
(** Return the [n]-th element of the given list.
The first element (head of the list) is at position 0.
Return [None] if the list is too short.
- Raise [Invalid_argument "List.nth"] if [n] is negative.
+ @raise Invalid_argument if [n] is negative.
@since 4.05
*)
@since 4.10.0
*)
+val fold_left_map : ('a -> 'b -> 'a * 'c) -> 'a -> 'b list -> 'a * 'c list
+(** [fold_left_map] is a combination of [fold_left] and [map] that threads an
+ accumulator through calls to [f]
+ @since 4.11.0
+*)
+
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a
(** [List.fold_left f a [b1; ...; bn]] is
[f (... (f (f a b1) b2) ...) bn]. *)
val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit
(** [List.iter2 f [a1; ...; an] [b1; ...; bn]] calls in turn
[f a1 b1; ...; f an bn].
- Raise [Invalid_argument] if the two lists are determined
+ @raise Invalid_argument if the two lists are determined
to have different lengths. *)
val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
(** [List.map2 f [a1; ...; an] [b1; ...; bn]] is
[[f a1 b1; ...; f an bn]].
- Raise [Invalid_argument] if the two lists are determined
+ @raise Invalid_argument if the two lists are determined
to have different lengths. Not tail-recursive. *)
val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a
(** [List.fold_left2 f a [b1; ...; bn] [c1; ...; cn]] is
[f (... (f (f a b1 c1) b2 c2) ...) bn cn].
- Raise [Invalid_argument] if the two lists are determined
+ @raise Invalid_argument if the two lists are determined
to have different lengths. *)
val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c
(** [List.fold_right2 f [a1; ...; an] [b1; ...; bn] c] is
[f a1 b1 (f a2 b2 (... (f an bn c) ...))].
- Raise [Invalid_argument] if the two lists are determined
+ @raise Invalid_argument if the two lists are determined
to have different lengths. Not tail-recursive. *)
val for_all : ('a -> bool) -> 'a list -> bool
(** [for_all p [a1; ...; an]] checks if all elements of the list
satisfy the predicate [p]. That is, it returns
- [(p a1) && (p a2) && ... && (p an)]. *)
+ [(p a1) && (p a2) && ... && (p an)] for a non-empty list and
+ [true] if the list is empty. *)
val exists : ('a -> bool) -> 'a list -> bool
(** [exists p [a1; ...; an]] checks if at least one element of
the list satisfies the predicate [p]. That is, it returns
- [(p a1) || (p a2) || ... || (p an)]. *)
+ [(p a1) || (p a2) || ... || (p an)] for a non-empty list and
+ [false] if the list is empty. *)
val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
(** Same as {!List.for_all}, but for a two-argument predicate.
- Raise [Invalid_argument] if the two lists are determined
+ @raise Invalid_argument if the two lists are determined
to have different lengths. *)
val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
(** Same as {!List.exists}, but for a two-argument predicate.
- Raise [Invalid_argument] if the two lists are determined
+ @raise Invalid_argument if the two lists are determined
to have different lengths. *)
val mem : 'a -> 'a list -> bool
val find : ('a -> bool) -> 'a list -> 'a
(** [find p l] returns the first element of the list [l]
that satisfies the predicate [p].
- Raise [Not_found] if there is no value that satisfies [p] in the
+ @raise Not_found if there is no value that satisfies [p] in the
list [l]. *)
val find_opt: ('a -> bool) -> 'a list -> 'a option
val find_all : ('a -> bool) -> 'a list -> 'a list
(** [find_all] is another name for {!List.filter}. *)
+val filteri : (int -> 'a -> bool) -> 'a list -> 'a list
+(** Same as {!List.filter}, but the predicate is applied to the index of
+ the element as first argument (counting from 0), and the element
+ itself as second argument.
+ @since 4.11.0
+*)
+
val partition : ('a -> bool) -> 'a list -> 'a list * 'a list
(** [partition p l] returns a pair of lists [(l1, l2)], where
[l1] is the list of all the elements of [l] that
pairs [l]. That is,
[assoc a [ ...; (a,b); ...] = b]
if [(a,b)] is the leftmost binding of [a] in list [l].
- Raise [Not_found] if there is no value associated with [a] in the
+ @raise Not_found if there is no value associated with [a] in the
list [l]. *)
val assoc_opt: 'a -> ('a * 'b) list -> 'b option
(** Transform a pair of lists into a list of pairs:
[combine [a1; ...; an] [b1; ...; bn]] is
[[(a1,b1); ...; (an,bn)]].
- Raise [Invalid_argument] if the two lists
+ @raise Invalid_argument if the two lists
have different lengths. Not tail-recursive. *)
(**************************************************************************)
type 'a t = 'a list = [] | (::) of 'a * 'a list (**)
-(** An alias for the type of lists. *)
+(** An alias for the type of lists.
+ *)
(** List operations.
open StdLabels
let seq len = List.init ~f:(function i -> i) ~len
- ]} *)
+ ]}
+ *)
val length : 'a list -> int
-(** Return the length (number of elements) of the given list. *)
+(** Return the length (number of elements) of the given list.
+ *)
val hd : 'a list -> 'a
-(** Return the first element of the given list. Raise
- [Failure "hd"] if the list is empty. *)
+(** Return the first element of the given list.
+ @raise Failure if the list is empty.
+ *)
val compare_lengths : 'a list -> 'b list -> int
(** Compare the lengths of two lists. [compare_lengths l1 l2] is
equivalent to [compare (length l) n], except that
the computation stops after at most [n] iterations on the list.
@since 4.05.0
-*)
+ *)
val cons : 'a -> 'a list -> 'a list
(** [cons x xs] is [x :: xs]
@since 4.05.0
-*)
+ *)
val tl : 'a list -> 'a list
-(** Return the given list without its first element. Raise
- [Failure "tl"] if the list is empty. *)
+(** Return the given list without its first element.
+ @raise Failure if the list is empty.
+ *)
val nth : 'a list -> int -> 'a
(** Return the [n]-th element of the given list.
The first element (head of the list) is at position 0.
- Raise [Failure "nth"] if the list is too short.
- Raise [Invalid_argument "List.nth"] if [n] is negative. *)
+ @raise Failure if the list is too short.
+ @raise Invalid_argument if [n] is negative.
+ *)
val nth_opt: 'a list -> int -> 'a option
(** Return the [n]-th element of the given list.
The first element (head of the list) is at position 0.
Return [None] if the list is too short.
- Raise [Invalid_argument "List.nth"] if [n] is negative.
+ @raise Invalid_argument if [n] is negative.
@since 4.05
-*)
+ *)
val rev : 'a list -> 'a list
-(** List reversal. *)
+(** List reversal.
+ *)
val init : len:int -> f:(int -> 'a) -> 'a list
(** [List.init len f] is [f 0; f 1; ...; f (len-1)], evaluated left to right.
-
@raise Invalid_argument if [len < 0].
@since 4.06.0
-*)
+ *)
val append : 'a list -> 'a list -> 'a list
-(** Catenate two lists. Same function as the infix operator [@].
- Not tail-recursive (length of the first argument). The [@]
- operator is not tail-recursive either. *)
+(** Catenate two lists. Same function as the infix operator [@].
+ Not tail-recursive (length of the first argument). The [@]
+ operator is not tail-recursive either.
+ *)
val rev_append : 'a list -> 'a list -> 'a list
(** [List.rev_append l1 l2] reverses [l1] and concatenates it with [l2].
This is equivalent to [(]{!List.rev}[ l1) @ l2], but [rev_append] is
- tail-recursive and more efficient. *)
+ tail-recursive and more efficient.
+ *)
val concat : 'a list list -> 'a list
-(** Concatenate a list of lists. The elements of the argument are all
+(** Concatenate a list of lists. The elements of the argument are all
concatenated together (in the same order) to give the result.
Not tail-recursive
- (length of the argument + length of the longest sub-list). *)
+ (length of the argument + length of the longest sub-list).
+ *)
val flatten : 'a list list -> 'a list
-(** Same as [concat]. Not tail-recursive
- (length of the argument + length of the longest sub-list). *)
+(** Same as [concat]. Not tail-recursive
+ (length of the argument + length of the longest sub-list).
+ *)
(** {1 Iterators} *)
val iter : f:('a -> unit) -> 'a list -> unit
(** [List.iter f [a1; ...; an]] applies function [f] in turn to
[a1; ...; an]. It is equivalent to
- [begin f a1; f a2; ...; f an; () end]. *)
+ [begin f a1; f a2; ...; f an; () end].
+ *)
val iteri : f:(int -> 'a -> unit) -> 'a list -> unit
(** Same as {!List.iter}, but the function is applied to the index of
the element as first argument (counting from 0), and the element
itself as second argument.
@since 4.00.0
-*)
+ *)
val map : f:('a -> 'b) -> 'a list -> 'b list
(** [List.map f [a1; ...; an]] applies function [f] to [a1, ..., an],
and builds the list [[f a1; ...; f an]]
- with the results returned by [f]. Not tail-recursive. *)
+ with the results returned by [f]. Not tail-recursive.
+ *)
val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list
(** Same as {!List.map}, but the function is applied to the index of
the element as first argument (counting from 0), and the element
itself as second argument.
@since 4.00.0
-*)
+ *)
val rev_map : f:('a -> 'b) -> 'a list -> 'b list
(** [List.rev_map f l] gives the same result as
{!List.rev}[ (]{!List.map}[ f l)], but is tail-recursive and
- more efficient. *)
+ more efficient.
+ *)
val filter_map : f:('a -> 'b option) -> 'a list -> 'b list
(** [filter_map f l] applies [f] to every element of [l], filters
out the [None] elements and returns the list of the arguments of
the [Some] elements.
@since 4.08.0
-*)
+ *)
val concat_map : f:('a -> 'b list) -> 'a list -> 'b list
(** [List.concat_map f l] gives the same result as
@since 4.10.0
*)
+val fold_left_map :
+ f:('a -> 'b -> 'a * 'c) -> init:'a -> 'b list -> 'a * 'c list
+(** [fold_left_map] is a combination of [fold_left] and [map] hat threads an
+ accumulator through calls to [f]
+ @since 4.11.0
+*)
+
val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a
(** [List.fold_left f a [b1; ...; bn]] is
- [f (... (f (f a b1) b2) ...) bn]. *)
+ [f (... (f (f a b1) b2) ...) bn].
+ *)
val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b
(** [List.fold_right f [a1; ...; an] b] is
- [f a1 (f a2 (... (f an b) ...))]. Not tail-recursive. *)
+ [f a1 (f a2 (... (f an b) ...))]. Not tail-recursive.
+ *)
(** {1 Iterators on two lists} *)
val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit
(** [List.iter2 f [a1; ...; an] [b1; ...; bn]] calls in turn
[f a1 b1; ...; f an bn].
- Raise [Invalid_argument] if the two lists are determined
- to have different lengths. *)
+ @raise Invalid_argument if the two lists are determined
+ to have different lengths.
+ *)
val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
(** [List.map2 f [a1; ...; an] [b1; ...; bn]] is
[[f a1 b1; ...; f an bn]].
- Raise [Invalid_argument] if the two lists are determined
- to have different lengths. Not tail-recursive. *)
+ @raise Invalid_argument if the two lists are determined
+ to have different lengths. Not tail-recursive.
+ *)
val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
(** [List.rev_map2 f l1 l2] gives the same result as
{!List.rev}[ (]{!List.map2}[ f l1 l2)], but is tail-recursive and
- more efficient. *)
+ more efficient.
+ *)
val fold_left2 :
f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a
(** [List.fold_left2 f a [b1; ...; bn] [c1; ...; cn]] is
[f (... (f (f a b1 c1) b2 c2) ...) bn cn].
- Raise [Invalid_argument] if the two lists are determined
- to have different lengths. *)
+ @raise Invalid_argument if the two lists are determined
+ to have different lengths.
+ *)
val fold_right2 :
f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c
(** [List.fold_right2 f [a1; ...; an] [b1; ...; bn] c] is
[f a1 b1 (f a2 b2 (... (f an bn c) ...))].
- Raise [Invalid_argument] if the two lists are determined
- to have different lengths. Not tail-recursive. *)
+ @raise Invalid_argument if the two lists are determined
+ to have different lengths. Not tail-recursive.
+ *)
(** {1 List scanning} *)
val for_all : f:('a -> bool) -> 'a list -> bool
(** [for_all p [a1; ...; an]] checks if all elements of the list
satisfy the predicate [p]. That is, it returns
- [(p a1) && (p a2) && ... && (p an)]. *)
+ [(p a1) && (p a2) && ... && (p an)].
+ *)
val exists : f:('a -> bool) -> 'a list -> bool
(** [exists p [a1; ...; an]] checks if at least one element of
the list satisfies the predicate [p]. That is, it returns
- [(p a1) || (p a2) || ... || (p an)]. *)
+ [(p a1) || (p a2) || ... || (p an)].
+ *)
val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
(** Same as {!List.for_all}, but for a two-argument predicate.
- Raise [Invalid_argument] if the two lists are determined
- to have different lengths. *)
+ @raise Invalid_argument if the two lists are determined
+ to have different lengths.
+ *)
val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
(** Same as {!List.exists}, but for a two-argument predicate.
- Raise [Invalid_argument] if the two lists are determined
- to have different lengths. *)
+ @raise Invalid_argument if the two lists are determined
+ to have different lengths.
+ *)
val mem : 'a -> set:'a list -> bool
(** [mem a l] is true if and only if [a] is equal
- to an element of [l]. *)
+ to an element of [l].
+ *)
val memq : 'a -> set:'a list -> bool
(** Same as {!List.mem}, but uses physical equality instead of structural
- equality to compare list elements. *)
+ equality to compare list elements.
+ *)
(** {1 List searching} *)
val find : f:('a -> bool) -> 'a list -> 'a
(** [find p l] returns the first element of the list [l]
that satisfies the predicate [p].
- Raise [Not_found] if there is no value that satisfies [p] in the
- list [l]. *)
+ @raise Not_found if there is no value that satisfies [p] in the
+ list [l].
+ *)
val find_opt: f:('a -> bool) -> 'a list -> 'a option
(** [find p l] returns the first element of the list [l]
that satisfies the predicate [p].
Returns [None] if there is no value that satisfies [p] in the
list [l].
- @since 4.05 *)
+ @since 4.05
+ *)
val find_map: f:('a -> 'b option) -> 'a list -> 'b option
(** [find_map f l] applies [f] to the elements of [l] in order,
val filter : f:('a -> bool) -> 'a list -> 'a list
(** [filter p l] returns all the elements of the list [l]
- that satisfy the predicate [p]. The order of the elements
- in the input list is preserved. *)
+ that satisfy the predicate [p]. The order of the elements
+ in the input list is preserved.
+ *)
val find_all : f:('a -> bool) -> 'a list -> 'a list
-(** [find_all] is another name for {!List.filter}. *)
+(** [find_all] is another name for {!List.filter}.
+ *)
+
+val filteri : f:(int -> 'a -> bool) -> 'a list -> 'a list
+(** Same as {!List.filter}, but the predicate is applied to the index of
+ the element as first argument (counting from 0), and the element
+ itself as second argument.
+ @since 4.11.0
+*)
val partition : f:('a -> bool) -> 'a list -> 'a list * 'a list
(** [partition p l] returns a pair of lists [(l1, l2)], where
[l1] is the list of all the elements of [l] that
satisfy the predicate [p], and [l2] is the list of all the
elements of [l] that do not satisfy [p].
- The order of the elements in the input list is preserved. *)
+ The order of the elements in the input list is preserved.
+ *)
(** {1 Association lists} *)
pairs [l]. That is,
[assoc a [ ...; (a,b); ...] = b]
if [(a,b)] is the leftmost binding of [a] in list [l].
- Raise [Not_found] if there is no value associated with [a] in the
- list [l]. *)
+ @raise Not_found if there is no value associated with [a] in the
+ list [l].
+ *)
val assoc_opt: 'a -> ('a * 'b) list -> 'b option
(** [assoc_opt a l] returns the value associated with key [a] in the list of
Returns [None] if there is no value associated with [a] in the
list [l].
@since 4.05
-*)
+ *)
val assq : 'a -> ('a * 'b) list -> 'b
(** Same as {!List.assoc}, but uses physical equality instead of
- structural equality to compare keys. *)
+ structural equality to compare keys.
+ *)
val assq_opt: 'a -> ('a * 'b) list -> 'b option
(** Same as {!List.assoc_opt}, but uses physical equality instead of
structural equality to compare keys.
- @since 4.05.0 *)
+ @since 4.05.0
+ *)
val mem_assoc : 'a -> map:('a * 'b) list -> bool
(** Same as {!List.assoc}, but simply return true if a binding exists,
- and false if no bindings exist for the given key. *)
+ and false if no bindings exist for the given key.
+ *)
val mem_assq : 'a -> map:('a * 'b) list -> bool
(** Same as {!List.mem_assoc}, but uses physical equality instead of
- structural equality to compare keys. *)
+ structural equality to compare keys.
+ *)
val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
(** [remove_assoc a l] returns the list of
pairs [l] without the first pair with key [a], if any.
- Not tail-recursive. *)
+ Not tail-recursive.
+ *)
val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
(** Same as {!List.remove_assoc}, but uses physical equality instead
- of structural equality to compare keys. Not tail-recursive. *)
+ of structural equality to compare keys. Not tail-recursive.
+ *)
(** {1 Lists of pairs} *)
(** Transform a list of pairs into a pair of lists:
[split [(a1,b1); ...; (an,bn)]] is [([a1; ...; an], [b1; ...; bn])].
Not tail-recursive.
-*)
+ *)
val combine : 'a list -> 'b list -> ('a * 'b) list
(** Transform a pair of lists into a list of pairs:
[combine [a1; ...; an] [b1; ...; bn]] is
[[(a1,b1); ...; (an,bn)]].
- Raise [Invalid_argument] if the two lists
- have different lengths. Not tail-recursive. *)
+ @raise Invalid_argument if the two lists
+ have different lengths. Not tail-recursive.
+ *)
(** {1 Sorting} *)
val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
(** Sort a list in increasing order according to a comparison
- function. The comparison function must return 0 if its arguments
+ function. The comparison function must return 0 if its arguments
compare as equal, a positive integer if the first is greater,
and a negative integer if the first is smaller (see Array.sort for
- a complete specification). For example,
+ a complete specification). For example,
{!Stdlib.compare} is a suitable comparison function.
The resulting list is sorted in increasing order.
[List.sort] is guaranteed to run in constant heap space
The current implementation uses Merge Sort. It runs in constant
heap space and logarithmic stack space.
-*)
+ *)
val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
(** Same as {!List.sort}, but the sorting algorithm is guaranteed to
The current implementation uses Merge Sort. It runs in constant
heap space and logarithmic stack space.
-*)
+ *)
val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
(** Same as {!List.sort} or {!List.stable_sort}, whichever is
- faster on typical input. *)
+ faster on typical input.
+ *)
val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list
(** Same as {!List.sort}, but also remove duplicates.
- @since 4.03.0 *)
+ @since 4.03.0
+ *)
val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
(** Merge two lists:
If several elements compare equal, the elements of [l1] will be
before the elements of [l2].
Not tail-recursive (sum of the lengths of the arguments).
-*)
+ *)
(** {1 Iterators} *)
val to_seq : 'a list -> 'a Seq.t
(** Iterate on the list
- @since 4.07 *)
+ @since 4.07
+ *)
val of_seq : 'a Seq.t -> 'a list
(** Create a list from the iterator
- @since 4.07 *)
+ @since 4.07
+ *)
val for_all: (key -> 'a -> bool) -> 'a t -> bool
val exists: (key -> 'a -> bool) -> 'a t -> bool
val filter: (key -> 'a -> bool) -> 'a t -> 'a t
+ val filter_map: (key -> 'a -> 'b option) -> 'a t -> 'b t
val partition: (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal: 'a t -> int
val bindings: 'a t -> (key * 'a) list
if pvd then if l==l' && r==r' then m else join l' v d r'
else concat l' r'
+ let rec filter_map f = function
+ Empty -> Empty
+ | Node {l; v; d; r} ->
+ (* call [f] in the expected left-to-right order *)
+ let l' = filter_map f l in
+ let fvd = f v d in
+ let r' = filter_map f r in
+ begin match fvd with
+ | Some d' -> join l' v d' r'
+ | None -> concat l' r'
+ end
+
let rec partition p = function
Empty -> (Empty, Empty)
| Node {l; v; d; r} ->
val merge:
(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
- (** [merge f m1 m2] computes a map whose keys is a subset of keys of [m1]
- and of [m2]. The presence of each such binding, and the corresponding
- value, is determined with the function [f].
+ (** [merge f m1 m2] computes a map whose keys are a subset of the keys of
+ [m1] and of [m2]. The presence of each such binding, and the
+ corresponding value, is determined with the function [f].
In terms of the [find_opt] operation, we have
- [find_opt x (merge f m1 m2) = f (find_opt x m1) (find_opt x m2)]
- for any key [x], provided that [f None None = None].
+ [find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2)]
+ for any key [x], provided that [f x None None = None].
@since 3.12.0
*)
val union: (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
- (** [union f m1 m2] computes a map whose keys is the union of keys
+ (** [union f m1 m2] computes a map whose keys are a subset of the keys
of [m1] and of [m2]. When the same binding is defined in both
arguments, the function [f] is used to combine them.
This is a special case of [merge]: [union f m1 m2] is equivalent
val filter: (key -> 'a -> bool) -> 'a t -> 'a t
(** [filter p m] returns the map with all the bindings in [m]
- that satisfy predicate [p]. If [p] satisfies every binding in [m],
+ that satisfy predicate [p]. If every binding in [m] satisfies [p],
[m] is returned unchanged (the result of the function is then
physically equal to [m])
@since 3.12.0
@before 4.03 Physical equality was not ensured.
*)
+ val filter_map: (key -> 'a -> 'b option) -> 'a t -> 'b t
+ (** [filter_map f m] applies the function [f] to every binding of
+ [m], and builds a map from the results. For each binding
+ [(k, v)] in the input map:
+ - if [f k v] is [None] then [k] is not in the result,
+ - if [f k v] is [Some v'] then the binding [(k, v')]
+ is in the output map.
+
+ For example, the following function on maps whose values are lists
+ {[
+ filter_map
+ (fun _k li -> match li with [] -> None | _::tl -> Some tl)
+ m
+ ]}
+ drops all bindings of [m] whose value is an empty list, and pops
+ the first element of each value that is non-empty.
+
+ @since 4.11.0
+ *)
+
val partition: (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
(** [partition p m] returns a pair of maps [(m1, m2)], where
- [m1] contains all the bindings of [s] that satisfy the
+ [m1] contains all the bindings of [m] that satisfy the
predicate [p], and [m2] is the map with all the bindings of
- [s] that do not satisfy [p].
+ [m] that do not satisfy [p].
@since 3.12.0
*)
*)
val find: key -> 'a t -> 'a
- (** [find x m] returns the current binding of [x] in [m],
- or raises [Not_found] if no such binding exists. *)
+ (** [find x m] returns the current value of [x] in [m],
+ or raises [Not_found] if no binding for [x] exists. *)
val find_opt: key -> 'a t -> 'a option
- (** [find_opt x m] returns [Some v] if the current binding of [x]
- in [m] is [v], or [None] if no such binding exists.
+ (** [find_opt x m] returns [Some v] if the current value of [x]
+ in [m] is [v], or [None] if no binding for [x] exists.
@since 4.05
*)
val for_all: f:(key -> 'a -> bool) -> 'a t -> bool
val exists: f:(key -> 'a -> bool) -> 'a t -> bool
val filter: f:(key -> 'a -> bool) -> 'a t -> 'a t
+ val filter_map: f:(key -> 'a -> 'b option) -> 'a t -> 'b t
val partition: f:(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal: 'a t -> int
val bindings: 'a t -> (key * 'a) list
val for_all : f:(elt -> bool) -> t -> bool
val exists : f:(elt -> bool) -> t -> bool
val filter : f:(elt -> bool) -> t -> t
+ val filter_map : f:(elt -> elt option) -> t -> t
val partition : f:(elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
(** Multiplication. *)
external div : nativeint -> nativeint -> nativeint = "%nativeint_div"
-(** Integer division. Raise [Division_by_zero] if the second
- argument is zero. This division rounds the real quotient of
- its arguments towards zero, as specified for {!Stdlib.(/)}. *)
+(** Integer division. This division rounds the real quotient of
+ its arguments towards zero, as specified for {!Stdlib.(/)}.
+
+ @raise Division_by_zero if the second
+ argument is zero. *)
val unsigned_div : nativeint -> nativeint -> nativeint
(** Same as {!div}, except that arguments and result are interpreted as {e
it is converted to the signed integer
[Int64.min_int + input - Nativeint.max_int - 1].
- Raise [Failure "Nativeint.of_string"] if the given string is not
+ @raise Failure if the given string is not
a valid representation of an integer, or if the integer represented
exceeds the range of integers representable in type [nativeint]. *)
start_char : int;
end_char : int;
is_inline : bool;
+ defname : string;
}
| Unknown_location of {
is_raise : bool
(* to avoid warning *)
let _ = [Known_location { is_raise = false; filename = "";
line_number = 0; start_char = 0; end_char = 0;
- is_inline = false };
+ is_inline = false; defname = "" };
Unknown_location { is_raise = false }]
external convert_raw_backtrace_slot:
else
Some (sprintf "%s unknown location" (info false))
| Known_location l ->
- Some (sprintf "%s file \"%s\"%s, line %d, characters %d-%d"
- (info l.is_raise) l.filename
+ Some (sprintf "%s %s in file \"%s\"%s, line %d, characters %d-%d"
+ (info l.is_raise) l.defname l.filename
(if l.is_inline then " (inlined)" else "")
l.line_number l.start_char l.end_char)
end_char = l.end_char;
}
+let backtrace_slot_defname = function
+ | Unknown_location _
+ | Known_location { defname = "" } -> None
+ | Known_location l -> Some l.defname
+
let backtrace_slots raw_backtrace =
(* The documentation of this function guarantees that Some is
returned only if a part of the trace is usable. This gives us
let is_raise = backtrace_slot_is_raise
let is_inline = backtrace_slot_is_inline
let location = backtrace_slot_location
+ let name = backtrace_slot_defname
end
external raw_backtrace_length :
let slot = exn_slot x in
(Obj.obj (Obj.field slot 0) : string)
+let default_uncaught_exception_handler exn raw_backtrace =
+ eprintf "Fatal error: exception %s\n" (to_string exn);
+ print_raw_backtrace stderr raw_backtrace;
+ flush stderr
-let uncaught_exception_handler = ref None
+let uncaught_exception_handler = ref default_uncaught_exception_handler
-let set_uncaught_exception_handler fn = uncaught_exception_handler := Some fn
+let set_uncaught_exception_handler fn = uncaught_exception_handler := fn
let empty_backtrace : raw_backtrace = Obj.obj (Obj.new_block Obj.abstract_tag 0)
try_get_raw_backtrace ()
in
(try Stdlib.do_at_exit () with _ -> ());
- match !uncaught_exception_handler with
- | None ->
- eprintf "Fatal error: exception %s\n" (to_string exn);
- print_raw_backtrace stderr raw_backtrace;
- flush stderr
- | Some handler ->
- try
- handler exn raw_backtrace
- with exn' ->
- let raw_backtrace' = try_get_raw_backtrace () in
- eprintf "Fatal error: exception %s\n" (to_string exn);
- print_raw_backtrace stderr raw_backtrace;
- eprintf "Fatal error in uncaught exception handler: exception %s\n"
- (to_string exn');
- print_raw_backtrace stderr raw_backtrace';
- flush stderr
+ try
+ !uncaught_exception_handler exn raw_backtrace
+ with exn' ->
+ let raw_backtrace' = try_get_raw_backtrace () in
+ eprintf "Fatal error: exception %s\n" (to_string exn);
+ print_raw_backtrace stderr raw_backtrace;
+ eprintf "Fatal error in uncaught exception handler: exception %s\n"
+ (to_string exn');
+ print_raw_backtrace stderr raw_backtrace';
+ flush stderr
with
| Out_of_memory ->
prerr_endline
(** {1 Uncaught exceptions} *)
+val default_uncaught_exception_handler: exn -> raw_backtrace -> unit
+(** [Printexc.default_uncaught_exception_handler] prints the exception and
+ backtrace on standard error output.
+
+ @since 4.11
+*)
+
val set_uncaught_exception_handler: (exn -> raw_backtrace -> unit) -> unit
(** [Printexc.set_uncaught_exception_handler fn] registers [fn] as the handler
- for uncaught exceptions. The default handler prints the exception and
- backtrace on standard error output.
+ for uncaught exceptions. The default handler is
+ {!Printexc.default_uncaught_exception_handler}.
Note that when [fn] is called all the functions registered with
{!Stdlib.at_exit} have already been called. Because of this you must
@since 4.02
*)
+ val name : t -> string option
+ (** [name slot] returns the name of the function or definition
+ enclosing the location referred to by the slot.
+
+ [name slot] returns None if the name is unavailable, which
+ may happen for the same reasons as [location] returning None.
+
+ @since 4.11
+ *)
+
val format : int -> t -> string option
(** [format pos slot] returns the string representation of [slot] as
[raw_backtrace_to_string] would format it, assuming it is the
make_printf (fun acc -> bufput_acc b acc; k b) End_of_acc fmt
let ikfprintf k oc (Format (fmt, _)) =
make_iprintf k oc fmt
+let ikbprintf = ikfprintf
let fprintf oc fmt = kfprintf ignore oc fmt
let bprintf b fmt = kbprintf ignore b fmt
let ifprintf oc fmt = ikfprintf ignore oc fmt
+let ibprintf b fmt = ikbprintf ignore b fmt
let printf fmt = fprintf stdout fmt
let eprintf fmt = fprintf stderr fmt
@since 3.10.0
*)
+val ibprintf : Buffer.t -> ('a, Buffer.t, unit) format -> 'a
+(** Same as {!Printf.bprintf}, but does not print anything.
+ Useful to ignore some material when conditionally printing.
+ @since 4.11.0
+*)
+
(** Formatted output functions with continuations. *)
val kfprintf : (out_channel -> 'd) -> out_channel ->
@since 3.10.0
*)
+val ikbprintf : (Buffer.t -> 'd) -> Buffer.t ->
+ ('a, Buffer.t, unit, 'd) format4 -> 'a
+(** Same as [kbprintf] above, but does not print anything.
+ Useful to ignore some material when conditionally printing.
+ @since 4.11.0
+*)
+
(** Deprecated *)
val kprintf : (string -> 'b) -> ('a, unit, string, 'b) format4 -> 'a
(** [bscanf_format ic fmt f] reads a format string token from the formatted
input channel [ic], according to the given format string [fmt], and
applies [f] to the resulting format string value.
- Raise {!Scan_failure} if the format string value read does not have the
+ @raise Scan_failure if the format string value read does not have the
same type as [fmt].
@since 3.09.0
*)
('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6
(** [format_from_string s fmt] converts a string argument to a format string,
according to the given format string [fmt].
- Raise {!Scan_failure} if [s], considered as a format string, does not
+ @raise Scan_failure if [s], considered as a format string, does not
have the same type as [fmt].
@since 3.10.0
*)
Always return a copy of the argument, even if there is no escape sequence
in the argument.
- Raise {!Scan_failure} if [s] is not properly escaped (i.e. [s] has invalid
+ @raise Scan_failure if [s] is not properly escaped (i.e. [s] has invalid
escape sequences or special characters that are not properly escaped).
For instance, [Scanf.unescaped "\""] will fail.
@since 4.00.0
let return x () = Cons (x, empty)
+let cons x next () = Cons (x, next)
+
+let rec append seq1 seq2 () =
+ match seq1() with
+ | Nil -> seq2()
+ | Cons (x, next) -> Cons (x, append next seq2)
+
let rec map f seq () = match seq() with
| Nil -> Nil
| Cons (x, next) -> Cons (f x, map f next)
aux next
in
aux seq
+
+let rec unfold f u () =
+ match f u with
+ | None -> Nil
+ | Some (x, u') -> Cons (x, unfold f u')
and +'a node =
| Nil
- | Cons of 'a * 'a t
+ | Cons of 'a * 'a t (**)
(** A fully-evaluated list node, either empty or containing an element
and a delayed tail. *)
val return : 'a -> 'a t
(** The singleton sequence containing only the given element. *)
+val cons : 'a -> 'a t -> 'a t
+(** [cons x xs] is the sequence containing the element [x] followed by
+ the sequence [xs] @since 4.11 *)
+
+val append : 'a t -> 'a t -> 'a t
+(** [append xs ys] is the sequence [xs] followed by the sequence [ys]
+ @since 4.11 *)
+
val map : ('a -> 'b) -> 'a t -> 'b t
(** [map f seq] returns a new sequence whose elements are the elements of
[seq], transformed by [f].
(** Iterate on the sequence, calling the (imperative) function on every element.
The traversal happens immediately and will not terminate on infinite
sequences. *)
+
+val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t
+(** Build a sequence from a step function and an initial value.
+ [unfold f u] returns [empty] if [f u] returns [None],
+ or [fun () -> Cons (x, unfold f y)] if [f u] returns [Some (x, y)].
+
+ For example, [unfold (function [] -> None | h::t -> Some (h,t)) l]
+ is equivalent to [List.to_seq l].
+ @since 4.11 *)
val for_all: (elt -> bool) -> t -> bool
val exists: (elt -> bool) -> t -> bool
val filter: (elt -> bool) -> t -> t
+ val filter_map: (elt -> elt option) -> t -> t
val partition: (elt -> bool) -> t -> t * t
val cardinal: t -> int
val elements: t -> elt list
if l == l' && v == v' && r == r' then t
else try_join l' v' r'
+ let try_concat t1 t2 =
+ match (t1, t2) with
+ (Empty, t) -> t
+ | (t, Empty) -> t
+ | (_, _) -> try_join t1 (min_elt t2) (remove_min_elt t2)
+
+ let rec filter_map f = function
+ | Empty -> Empty
+ | Node{l; v; r} as t ->
+ (* enforce left-to-right evaluation order *)
+ let l' = filter_map f l in
+ let v' = f v in
+ let r' = filter_map f r in
+ begin match v' with
+ | Some v' ->
+ if l == l' && v == v' && r == r' then t
+ else try_join l' v' r'
+ | None ->
+ try_concat l' r'
+ end
+
let of_sorted_list l =
let rec sub n l =
match n, l with
physically equal to [s]).
@before 4.03 Physical equality was not ensured.*)
+ val filter_map: (elt -> elt option) -> t -> t
+ (** [filter_map f s] returns the set of all [v] such that
+ [f x = Some v] for some element [x] of [s].
+
+ For example,
+ {[filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) s]}
+ is the set of halves of the even elements of [s].
+
+ If no element of [s] is changed or dropped by [f] (if
+ [f x = Some x] for each element [x]), then
+ [s] is returned unchanged: the result of the function
+ is then physically equal to [s].
+
+ @since 4.11.0
+ *)
+
val partition: (elt -> bool) -> t -> t * t
(** [partition p s] returns a pair of sets [(s1, s2)], where
[s1] is the set of all the elements of [s] that satisfy the
external ( / ) : int -> int -> int = "%divint"
(** Integer division.
- Raise [Division_by_zero] if the second argument is 0.
Integer division rounds the real quotient of its arguments towards zero.
More precisely, if [x >= 0] and [y > 0], [x / y] is the greatest integer
less than or equal to the real quotient of [x] by [y]. Moreover,
[(- x) / y = x / (- y) = - (x / y)].
Left-associative operator, see {!Ocaml_operators} for more information.
+
+ @raise Division_by_zero if the second argument is 0.
*)
external ( mod ) : int -> int -> int = "%modint"
[abs(x mod y) <= abs(y) - 1].
If [y = 0], [x mod y] raises [Division_by_zero].
Note that [x mod y] is negative only if [x < 0].
- Raise [Division_by_zero] if [y] is zero.
Left-associative operator, see {!Ocaml_operators} for more information.
+
+ @raise Division_by_zero if [y] is zero.
*)
val abs : int -> int
val char_of_int : int -> char
(** Return the character with the given ASCII code.
- Raise [Invalid_argument "char_of_int"] if the argument is
+ @raise Invalid_argument if the argument is
outside the range 0--255. *)
val output : out_channel -> bytes -> int -> int -> unit
(** [output oc buf pos len] writes [len] characters from byte sequence [buf],
starting at offset [pos], to the given output channel [oc].
- Raise [Invalid_argument "output"] if [pos] and [len] do not
+ @raise Invalid_argument if [pos] and [len] do not
designate a valid range of [buf]. *)
val output_substring : out_channel -> string -> int -> int -> unit
val input_char : in_channel -> char
(** Read one character from the given input channel.
- Raise [End_of_file] if there are no more characters to read. *)
+ @raise End_of_file if there are no more characters to read. *)
val input_line : in_channel -> string
(** Read characters from the given input channel, until a
newline character is encountered. Return the string of
all characters read, without the newline character at the end.
- Raise [End_of_file] if the end of the file is reached
+ @raise End_of_file if the end of the file is reached
at the beginning of line. *)
val input : in_channel -> bytes -> int -> int -> int
val really_input : in_channel -> bytes -> int -> int -> unit
(** [really_input ic buf pos len] reads [len] characters from channel [ic],
storing them in byte sequence [buf], starting at character number [pos].
- Raise [End_of_file] if the end of file is reached before [len]
+ @raise End_of_file if the end of file is reached before [len]
characters have been read.
- Raise [Invalid_argument "really_input"] if
+ @raise Invalid_argument if
[pos] and [len] do not designate a valid range of [buf]. *)
val really_input_string : in_channel -> int -> string
(** [really_input_string ic len] reads [len] characters from channel [ic]
and returns them in a new string.
- Raise [End_of_file] if the end of file is reached before [len]
+ @raise End_of_file if the end of file is reached before [len]
characters have been read.
@since 4.02.0 *)
val input_byte : in_channel -> int
(** Same as {!Stdlib.input_char}, but return the 8-bit integer representing
the character.
- Raise [End_of_file] if an end of file was reached. *)
+ @raise End_of_file if an end of file was reached. *)
val input_binary_int : in_channel -> int
(** Read an integer encoded in binary format (4 bytes, big-endian)
from the given input channel. See {!Stdlib.output_binary_int}.
- Raise [End_of_file] if an end of file was reached while reading the
+ @raise End_of_file if an end of file was reached while reading the
integer. *)
val input_value : in_channel -> 'a
val next : 'a t -> 'a
(** Return the first element of the stream and remove it from the
- stream. Raise {!Stream.Failure} if the stream is empty. *)
+ stream.
+ @raise Stream.Failure if the stream is empty. *)
val empty : 'a t -> unit
(** Return [()] if the stream is empty, else raise {!Stream.Failure}. *)
external get : string -> int -> char = "%string_safe_get"
(** [String.get s n] returns the character at index [n] in string [s].
You can also write [s.[n]] instead of [String.get s n].
-
- Raise [Invalid_argument] if [n] not a valid index in [s]. *)
+ @raise Invalid_argument if [n] not a valid index in [s]. *)
external set : bytes -> int -> char -> unit = "%string_safe_set"
(** [String.set s n c] modifies byte sequence [s] in place,
replacing the byte at index [n] with [c].
You can also write [s.[n] <- c] instead of [String.set s n c].
-
- Raise [Invalid_argument] if [n] is not a valid index in [s].
+ @raise Invalid_argument if [n] is not a valid index in [s].
@deprecated This is a deprecated alias of {!Bytes.set}.[ ] *)
[@@ocaml.deprecated "Use Bytes.create instead."]
(** [String.create n] returns a fresh byte sequence of length [n].
The sequence is uninitialized and contains arbitrary bytes.
-
- Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}.
+ @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}.
@deprecated This is a deprecated alias of {!Bytes.create}.[ ] *)
val make : int -> char -> string
(** [String.make n c] returns a fresh string of length [n],
filled with the character [c].
-
- Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *)
+ @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. *)
val init : int -> (int -> char) -> string
(** [String.init n f] returns a string of length [n], with character
[i] initialized to the result of [f i] (called in increasing
index order).
- Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}.
-
+ @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}.
@since 4.02.0
*)
(** [String.sub s start len] returns a fresh string of length [len],
containing the substring of [s] that starts at position [start] and
has length [len].
-
- Raise [Invalid_argument] if [start] and [len] do not
+ @raise Invalid_argument if [start] and [len] do not
designate a valid substring of [s]. *)
val fill : bytes -> int -> int -> char -> unit
[@@ocaml.deprecated "Use Bytes.fill instead."]
(** [String.fill s start len c] modifies byte sequence [s] in place,
replacing [len] bytes with [c], starting at [start].
-
- Raise [Invalid_argument] if [start] and [len] do not
+ @raise Invalid_argument if [start] and [len] do not
designate a valid range of [s].
@deprecated This is a deprecated alias of {!Bytes.fill}.[ ] *)
val concat : string -> string list -> string
(** [String.concat sep sl] concatenates the list of strings [sl],
inserting the separator string [sep] between each.
-
- Raise [Invalid_argument] if the result is longer than
+ @raise Invalid_argument if the result is longer than
{!Sys.max_string_length} bytes. *)
val iter : (char -> unit) -> string -> unit
If there is no special character in the argument that needs
escaping, return the original string itself, not a copy.
-
- Raise [Invalid_argument] if the result is longer than
+ @raise Invalid_argument if the result is longer than
{!Sys.max_string_length} bytes.
The function {!Scanf.unescaped} is a left inverse of [escaped],
val index : string -> char -> int
(** [String.index s c] returns the index of the first
occurrence of character [c] in string [s].
-
- Raise [Not_found] if [c] does not occur in [s]. *)
+ @raise Not_found if [c] does not occur in [s]. *)
val index_opt: string -> char -> int option
(** [String.index_opt s c] returns the index of the first
val rindex : string -> char -> int
(** [String.rindex s c] returns the index of the last
occurrence of character [c] in string [s].
-
- Raise [Not_found] if [c] does not occur in [s]. *)
+ @raise Not_found if [c] does not occur in [s]. *)
val rindex_opt: string -> char -> int option
(** [String.rindex_opt s c] returns the index of the last occurrence
(** [String.index_from s i c] returns the index of the
first occurrence of character [c] in string [s] after position [i].
[String.index s c] is equivalent to [String.index_from s 0 c].
-
- Raise [Invalid_argument] if [i] is not a valid position in [s].
- Raise [Not_found] if [c] does not occur in [s] after position [i]. *)
+ @raise Invalid_argument if [i] is not a valid position in [s].
+ @raise Not_found if [c] does not occur in [s] after position [i]. *)
val index_from_opt: string -> int -> char -> int option
(** [String.index_from_opt s i c] returns the index of the
or [None] if [c] does not occur in [s] after position [i].
[String.index_opt s c] is equivalent to [String.index_from_opt s 0 c].
- Raise [Invalid_argument] if [i] is not a valid position in [s].
+ @raise Invalid_argument if [i] is not a valid position in [s].
@since 4.05
*)
last occurrence of character [c] in string [s] before position [i+1].
[String.rindex s c] is equivalent to
[String.rindex_from s (String.length s - 1) c].
-
- Raise [Invalid_argument] if [i+1] is not a valid position in [s].
- Raise [Not_found] if [c] does not occur in [s] before position [i+1]. *)
+ @raise Invalid_argument if [i+1] is not a valid position in [s].
+ @raise Not_found if [c] does not occur in [s] before position [i+1]. *)
val rindex_from_opt: string -> int -> char -> int option
(** [String.rindex_from_opt s i c] returns the index of the
[String.rindex_opt s c] is equivalent to
[String.rindex_from_opt s (String.length s - 1) c].
-
- Raise [Invalid_argument] if [i+1] is not a valid position in [s].
+ @raise Invalid_argument if [i+1] is not a valid position in [s].
@since 4.05
*)
appears in [s] after position [start].
[String.contains s c] is equivalent to
[String.contains_from s 0 c].
-
- Raise [Invalid_argument] if [start] is not a valid position in [s]. *)
+ @raise Invalid_argument if [start] is not a valid position in [s]. *)
val rcontains_from : string -> int -> char -> bool
(** [String.rcontains_from s stop c] tests if character [c]
appears in [s] before position [stop+1].
-
- Raise [Invalid_argument] if [stop < 0] or [stop+1] is not a valid
+ @raise Invalid_argument if [stop < 0] or [stop+1] is not a valid
position in [s]. *)
val uppercase : string -> string
external get : string -> int -> char = "%string_safe_get"
(** [String.get s n] returns the character at index [n] in string [s].
You can also write [s.[n]] instead of [String.get s n].
-
- Raise [Invalid_argument] if [n] not a valid index in [s]. *)
+ @raise Invalid_argument if [n] not a valid index in [s]. *)
external set : bytes -> int -> char -> unit = "%string_safe_set"
[@@ocaml.deprecated "Use BytesLabels.set instead."]
(** [String.set s n c] modifies byte sequence [s] in place,
replacing the byte at index [n] with [c].
You can also write [s.[n] <- c] instead of [String.set s n c].
-
- Raise [Invalid_argument] if [n] is not a valid index in [s].
+ @raise Invalid_argument if [n] is not a valid index in [s].
@deprecated This is a deprecated alias of {!BytesLabels.set}. *)
[@@ocaml.deprecated "Use BytesLabels.create instead."]
(** [String.create n] returns a fresh byte sequence of length [n].
The sequence is uninitialized and contains arbitrary bytes.
-
- Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}.
+ @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}.
@deprecated This is a deprecated alias of {!BytesLabels.create}. *)
val make : int -> char -> string
(** [String.make n c] returns a fresh string of length [n],
filled with the character [c].
-
- Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *)
+ @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}. *)
val init : int -> f:(int -> char) -> string
(** [init n f] returns a string of length [n],
with character [i] initialized to the result of [f i].
-
- Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}.
+ @raise Invalid_argument if [n < 0] or [n > ]{!Sys.max_string_length}.
@since 4.02.0 *)
val copy : string -> string [@@ocaml.deprecated]
(** [String.sub s start len] returns a fresh string of length [len],
containing the substring of [s] that starts at position [start] and
has length [len].
-
- Raise [Invalid_argument] if [start] and [len] do not
+ @raise Invalid_argument if [start] and [len] do not
designate a valid substring of [s]. *)
val fill : bytes -> pos:int -> len:int -> char -> unit
[@@ocaml.deprecated "Use BytesLabels.fill instead."]
(** [String.fill s start len c] modifies byte sequence [s] in place,
replacing [len] bytes by [c], starting at [start].
-
- Raise [Invalid_argument] if [start] and [len] do not
+ @raise Invalid_argument if [start] and [len] do not
designate a valid substring of [s].
@deprecated This is a deprecated alias of {!BytesLabels.fill}. *)
(** [String.blit src srcoff dst dstoff len] copies [len] bytes
from the string [src], starting at index [srcoff],
to byte sequence [dst], starting at character number [dstoff].
-
- Raise [Invalid_argument] if [srcoff] and [len] do not
+ @raise Invalid_argument if [srcoff] and [len] do not
designate a valid range of [src], or if [dstoff] and [len]
do not designate a valid range of [dst]. *)
val index : string -> char -> int
(** [String.index s c] returns the index of the first
occurrence of character [c] in string [s].
-
- Raise [Not_found] if [c] does not occur in [s]. *)
+ @raise Not_found if [c] does not occur in [s]. *)
val index_opt: string -> char -> int option
(** [String.index_opt s c] returns the index of the first
val rindex : string -> char -> int
(** [String.rindex s c] returns the index of the last
occurrence of character [c] in string [s].
-
- Raise [Not_found] if [c] does not occur in [s]. *)
+ @raise Not_found if [c] does not occur in [s]. *)
val rindex_opt: string -> char -> int option
(** [String.rindex_opt s c] returns the index of the last occurrence
(** [String.index_from s i c] returns the index of the
first occurrence of character [c] in string [s] after position [i].
[String.index s c] is equivalent to [String.index_from s 0 c].
-
- Raise [Invalid_argument] if [i] is not a valid position in [s].
- Raise [Not_found] if [c] does not occur in [s] after position [i]. *)
+ @raise Invalid_argument if [i] is not a valid position in [s].
+ @raise Not_found if [c] does not occur in [s] after position [i]. *)
val index_from_opt: string -> int -> char -> int option
(** [String.index_from_opt s i c] returns the index of the
or [None] if [c] does not occur in [s] after position [i].
[String.index_opt s c] is equivalent to [String.index_from_opt s 0 c].
- Raise [Invalid_argument] if [i] is not a valid position in [s].
+ @raise Invalid_argument if [i] is not a valid position in [s].
@since 4.05
*)
last occurrence of character [c] in string [s] before position [i+1].
[String.rindex s c] is equivalent to
[String.rindex_from s (String.length s - 1) c].
-
- Raise [Invalid_argument] if [i+1] is not a valid position in [s].
- Raise [Not_found] if [c] does not occur in [s] before position [i+1]. *)
+ @raise Invalid_argument if [i+1] is not a valid position in [s].
+ @raise Not_found if [c] does not occur in [s] before position [i+1]. *)
val rindex_from_opt: string -> int -> char -> int option
(** [String.rindex_from_opt s i c] returns the index of the
[String.rindex_opt s c] is equivalent to
[String.rindex_from_opt s (String.length s - 1) c].
-
- Raise [Invalid_argument] if [i+1] is not a valid position in [s].
+ @raise Invalid_argument if [i+1] is not a valid position in [s].
@since 4.05
*)
appears in [s] after position [start].
[String.contains s c] is equivalent to
[String.contains_from s 0 c].
-
- Raise [Invalid_argument] if [start] is not a valid position in [s]. *)
+ @raise Invalid_argument if [start] is not a valid position in [s]. *)
val rcontains_from : string -> int -> char -> bool
(** [String.rcontains_from s stop c] tests if character [c]
appears in [s] before position [stop+1].
-
- Raise [Invalid_argument] if [stop < 0] or [stop+1] is not a valid
+ @raise Invalid_argument if [stop < 0] or [stop+1] is not a valid
position in [s]. *)
val uppercase : string -> string
external is_directory : string -> bool = "caml_sys_is_directory"
(** Returns [true] if the given name refers to a directory,
[false] if it refers to another kind of file.
- Raise [Sys_error] if no file exists with the given name.
+ @raise Sys_error if no file exists with the given name.
@since 3.10.0
*)
external getenv : string -> string = "caml_sys_getenv"
(** Return the value associated to a variable in the process
- environment. Raise [Not_found] if the variable is unbound. *)
+ environment.
+ @raise Not_found if the variable is unbound. *)
val getenv_opt: string -> string option
(** Return the value associated to a variable in the process
such as file redirections [>] and [<], which will be honored by the
shell.
- Conversely, whitespace or special shell characters occuring in
+ Conversely, whitespace or special shell characters occurring in
command names or in their arguments must be quoted or escaped
so that the shell does not interpret them. The quoting rules vary
between the POSIX shell and the Windows shell.
val ocaml_version : string
(** [ocaml_version] is the version of OCaml.
- It is a string of the form ["major.minor[.patchlevel][+additional-info]"],
+ It is a string of the form
+ ["major.minor[.patchlevel][(+|~)additional-info]"],
where [major], [minor], and [patchlevel] are integers, and
- [additional-info] is an arbitrary string. The [[.patchlevel]] and
- [[+additional-info]] parts may be absent. *)
+ [additional-info] is an arbitrary string.
+ The [[.patchlevel]] part is absent for versions anterior to 3.08.0.
+ The [[(+|~)additional-info]] part may be absent. *)
val enable_runtime_warnings: bool -> unit
(** {1:unit The unit type} *)
-type t = unit = ()
+type t = unit = () (**)
(** The unit type.
The constructor [()] is included here so that it has a path,
val create : int -> 'a t
(** [Weak.create n] returns a new weak array of length [n].
- All the pointers are initially empty. Raise [Invalid_argument]
+ All the pointers are initially empty.
+ @raise Invalid_argument
if [n] is not comprised between zero and
{!Obj.Ephemeron.max_ephe_length} (limits included).*)
(** [Weak.set ar n (Some el)] sets the [n]th cell of [ar] to be a
(full) pointer to [el]; [Weak.set ar n None] sets the [n]th
cell of [ar] to empty.
- Raise [Invalid_argument "Weak.set"] if [n] is not in the range
+ @raise Invalid_argument if [n] is not in the range
0 to {!Weak.length}[ a - 1].*)
val get : 'a t -> int -> 'a option
(** [Weak.get ar n] returns None if the [n]th cell of [ar] is
empty, [Some x] (where [x] is the value) if it is full.
- Raise [Invalid_argument "Weak.get"] if [n] is not in the range
+ @raise Invalid_argument if [n] is not in the range
0 to {!Weak.length}[ a - 1].*)
val get_copy : 'a t -> int -> 'a option
difference with [get] is that [get_copy] does not prevent
the incremental GC from erasing the value in its current cycle
([get] may delay the erasure to the next GC cycle).
- Raise [Invalid_argument "Weak.get"] if [n] is not in the range
+ @raise Invalid_argument if [n] is not in the range
0 to {!Weak.length}[ a - 1].
If the element is a custom block it is not copied.
val fill : 'a t -> int -> int -> 'a option -> unit
(** [Weak.fill ar ofs len el] sets to [el] all pointers of [ar] from
- [ofs] to [ofs + len - 1]. Raise [Invalid_argument "Weak.fill"]
+ [ofs] to [ofs + len - 1].
+ @raise Invalid_argument
if [ofs] and [len] do not designate a valid subarray of [a].*)
val blit : 'a t -> int -> 'a t -> int -> int -> unit
(** [Weak.blit ar1 off1 ar2 off2 len] copies [len] weak pointers
from [ar1] (starting at [off1]) to [ar2] (starting at [off2]).
It works correctly even if [ar1] and [ar2] are the same.
- Raise [Invalid_argument "Weak.blit"] if [off1] and [len] do
+ @raise Invalid_argument if [off1] and [len] do
not designate a valid subarray of [ar1], or if [off2] and [len]
do not designate a valid subarray of [ar2].*)
val find : t -> data -> data
(** [find t x] returns an instance of [x] found in [t].
- Raise [Not_found] if there is no such element. *)
+ @raise Not_found if there is no such element. *)
val find_opt: t -> data -> data option
(** [find_opt t x] returns an instance of [x] found in [t]
#* *
#**************************************************************************
+.NOTPARALLEL:
+
BASEDIR := $(shell pwd)
NO_PRINT=`$(MAKE) empty --no-print-directory >/dev/null 2>&1 \
&& echo --no-print-directory`
$(ocamltest_program)
endif
+# PROMOTE is only meant to be used internally in recursive calls;
+# users should call the 'promote' target explicitly.
+PROMOTE =
+ifeq "$(PROMOTE)" ""
+ OCAMLTEST_PROMOTE_FLAG :=
+else
+ OCAMLTEST_PROMOTE_FLAG := -promote
+endif
+
+# KEEP_TEST_DIR_ON_SUCCESS should be set by the user (to a non-empty value)
+# if they want to pass the -keep-test-dir-on-success option to ocamltest,
+# to preserve test data of succesful tests.
+KEEP_TEST_DIR_ON_SUCCESS ?=
+ifeq "$(KEEP_TEST_DIR_ON_SUCCESS)" ""
+ OCAMLTEST_KEEP_TEST_DIR_ON_SUCCESS_FLAG :=
+else
+ OCAMLTEST_KEEP_TEST_DIR_ON_SUCCESS_FLAG := -keep-test-dir-on-success
+endif
+
+OCAMLTESTFLAGS := \
+ $(OCAMLTEST_PROMOTE_FLAG) \
+ $(OCAMLTEST_KEEP_TEST_DIR_ON_SUCCESS_FLAG)
+
.PHONY: default
default:
@echo "Available targets:"
$(ocamltest) -find-test-dirs tests | while read dir; do \
echo Running tests from \'$$dir\' ... ; \
$(MAKE) exec-ocamltest DIR=$$dir \
- OCAMLTESTENV="" OCAMLTESTFLAGS=""; \
+ OCAMLTESTENV=""; \
done || echo outer loop >> $(failstamp)) 2>&1 | tee -a $(TESTLOG)
@$(MAKE) check-failstamp
@if $(ocamltest) -list-tests $(DIR) >/dev/null 2>&1; then \
echo "Running tests from '$$DIR' ..."; \
$(MAKE) exec-ocamltest DIR=$(DIR) \
- OCAMLTESTENV="OCAMLTESTDIR=$(OCAMLTESTDIR_CYGPATH)" \
- OCAMLTESTFLAGS=""; \
+ OCAMLTESTENV="OCAMLTESTDIR=$(OCAMLTESTDIR_CYGPATH)"; \
else \
for dir in $(DIR)/*; do \
if [ -d $$dir ]; then \
@if $(ocamltest) -list-tests $(DIR) >/dev/null 2>&1; then \
$(MAKE) exec-ocamltest DIR=$(DIR) \
OCAMLTESTENV="OCAMLTESTDIR=$(OCAMLTESTDIR_CYGPATH)" \
- OCAMLTESTFLAGS="-promote"; \
+ PROMOTE="true"; \
else \
cd $(DIR) && $(MAKE) TERM=dumb BASEDIR=$(BASEDIR) promote; \
fi
#* *
#**************************************************************************
+.NOTPARALLEL:
+
TOPDIR = ../..
COMPFLAGS ?=
RUNTIME_VARIANT ?=
.PHONY: clean
clean:
- rm -f *.cm* *.$(O) *.$(A)
+ rm -f *.cm* *.o *.obj *.a *.lib
assert (Array.for_all (fun _ -> true) a);
;;
+let does_raise3 f a b c =
+ try
+ ignore (f a b c);
+ false
+ with _ ->
+ true
+
+let () =
+ let a = [|1;2;3;4;5;6;7;8;9|]
+ and b = [|1;2;3;4;5;6;7;8;9|] in
+ assert (Array.exists2 (fun a b -> a = b) a b);
+ assert (Array.exists2 (fun a b -> a - b = 0) a b);
+ assert (Array.exists2 (fun a b -> a = 1 && b = 1) a b);
+ assert (Array.exists2 (fun a b -> a = 2 && b = 2) a b);
+ assert (Array.exists2 (fun a b -> a = 3 && b = 3) a b);
+ assert (Array.exists2 (fun a b -> a = 4 && b = 4) a b);
+ assert (Array.exists2 (fun a b -> a = 5 && b = 5) a b);
+ assert (Array.exists2 (fun a b -> a = 6 && b = 6) a b);
+ assert (Array.exists2 (fun a b -> a = 7 && b = 7) a b);
+ assert (Array.exists2 (fun a b -> a = 8 && b = 8) a b);
+ assert (Array.exists2 (fun a b -> a = 9 && b = 9) a b);
+ assert (not (Array.exists2 (fun a b -> a <> b) a b));
+;;
+
+let () =
+ let a = [|1|]
+ and b = [|1;2|] in
+ assert (does_raise3 Array.exists2 (fun a b -> a = b) a b);
+ assert (does_raise3 Array.exists2 (fun _ _ -> true) a b);
+ assert (does_raise3 Array.exists2 (fun _ _ -> false) a b);
+ assert (does_raise3 Array.exists2 (fun a b -> a = 1 && b = 1) a b);
+ assert (does_raise3 Array.exists2 (fun a b -> a = 2 && b = 2) a b);
+ assert (does_raise3 Array.exists2 (fun a b -> a = 3 && b = 3) a b);
+ assert (does_raise3 Array.exists2 (fun a b -> a = 4 && b = 4) a b);
+ assert (does_raise3 Array.exists2 (fun a b -> a = 5 && b = 5) a b);
+ assert (does_raise3 Array.exists2 (fun a b -> a = 6 && b = 6) a b);
+ assert (does_raise3 Array.exists2 (fun a b -> a = 7 && b = 7) a b);
+ assert (does_raise3 Array.exists2 (fun a b -> a = 8 && b = 8) a b);
+ assert (does_raise3 Array.exists2 (fun a b -> a = 9 && b = 9) a b);
+;;
+
+let () =
+ assert (Array.exists2 (=) [|1;2;3|] [|3;2;1|]);
+ assert (not (Array.exists2 (<>) [|1;2;3|] [|1;2;3|]));
+ assert (does_raise3 Array.exists2 (=) [|1;2|] [|3|]);
+ let f = Array.create_float 10 in
+ let g = Array.create_float 10 in
+ Array.fill f 0 10 1.0;
+ Array.fill g 0 10 1.0;
+ assert (Array.exists2 (fun a b -> a = 1.0 && b = 1.0) f g);
+;;
+
+let () =
+ let a = [|1;2;3;4;5;6;7;8;9|]
+ and b = [|1;2;3;4;5;6;7;8;9|] in
+ assert (Array.for_all2 (fun a b -> a = b) a b);
+ assert (Array.for_all2 (fun a b -> a - b = 0) a b);
+ assert (Array.for_all2 (fun a b -> a > 0 && b > 0) a b);
+ assert (Array.for_all2 (fun a b -> a < 10 && b < 10) a b);
+ assert (Array.for_all2 (fun a b -> if a = 1 then b = 1 else b <> 1) a b);
+ assert (Array.for_all2 (fun a b -> if a = 2 then b = 2 else b <> 2) a b);
+ assert (Array.for_all2 (fun a b -> if a = 3 then b = 3 else b <> 3) a b);
+ assert (Array.for_all2 (fun a b -> if a = 4 then b = 4 else b <> 4) a b);
+ assert (Array.for_all2 (fun a b -> if a = 5 then b = 5 else b <> 5) a b);
+ assert (Array.for_all2 (fun a b -> if a = 6 then b = 6 else b <> 6) a b);
+ assert (Array.for_all2 (fun a b -> if a = 7 then b = 7 else b <> 7) a b);
+ assert (Array.for_all2 (fun a b -> if a = 8 then b = 8 else b <> 8) a b);
+ assert (Array.for_all2 (fun a b -> if a = 9 then b = 9 else b <> 9) a b);
+ assert (not (Array.for_all2 (fun a b -> a <> b) a b));
+;;
+
+let () =
+ let a = [|1|]
+ and b = [|1;2|] in
+ assert (does_raise3 Array.for_all2 (fun a b -> a = b) a b);
+ assert (does_raise3 Array.for_all2 (fun _ _ -> true) a b);
+ assert (does_raise3 Array.for_all2 (fun _ _ -> false) a b);
+ assert (does_raise3 Array.for_all2 (fun a b -> a = 1 && b = 1) a b);
+ assert (does_raise3 Array.for_all2 (fun a b -> a = 2 && b = 2) a b);
+ assert (does_raise3 Array.for_all2 (fun a b -> a = 3 && b = 3) a b);
+ assert (does_raise3 Array.for_all2 (fun a b -> a = 4 && b = 4) a b);
+ assert (does_raise3 Array.for_all2 (fun a b -> a = 5 && b = 5) a b);
+ assert (does_raise3 Array.for_all2 (fun a b -> a = 6 && b = 6) a b);
+ assert (does_raise3 Array.for_all2 (fun a b -> a = 7 && b = 7) a b);
+ assert (does_raise3 Array.for_all2 (fun a b -> a = 8 && b = 8) a b);
+ assert (does_raise3 Array.for_all2 (fun a b -> a = 9 && b = 9) a b);
+;;
+
+let () =
+ assert (not (Array.for_all2 (=) [|1;2;3|] [|3;2;1|]));
+ assert (Array.for_all2 (=) [|1;2;3|] [|1;2;3|]);
+ assert (not (Array.for_all2 (<>) [|1;2;3|] [|3;2;1|]));
+ assert (does_raise3 Array.for_all2 (=) [|1;2;3|] [|1;2;3;4|]);
+ assert (does_raise3 Array.for_all2 (=) [|1;2|] [||]);
+;;
let () =
let a = [|1;2;3;4;5;6;7;8;9|] in
--- /dev/null
+File "0001-test.ml", line 1:
+Warning 24: bad source file name: "0001-test" is not a valid module name.
--- /dev/null
+(* TEST *)
--- /dev/null
+(* TEST
+ * native
+*)
+let[@inline never] float () = print_string "hello\n"; 42.
+let[@inline never] f () = compare (float ()) 0.5;;
+let _ = f ()
+
+let[@inline never] myint () = print_string "bye\n"; 42
+let[@inline never] g () = compare (myint ()) 5;;
+let _ = g ()
--- /dev/null
+hello
+bye
(seq (checkbound y 5) (addraset r 90 1))
(addraset r 90 0))
- (addraset r 91 (let res 1 (if (==f f g) [] (assign res 0)) res))
- (addraset r 92 (let res 1 (if (!=f f g) [] (assign res 0)) res))
- (addraset r 93 (let res 1 (if (<f f g) [] (assign res 0)) res))
- (addraset r 94 (let res 1 (if (>f f g) [] (assign res 0)) res))
- (addraset r 95 (let res 1 (if (<=f f g) [] (assign res 0)) res))
- (addraset r 96 (let res 1 (if (>=f f g) [] (assign res 0)) res))
+ (addraset r 91 (letmut res int 1 (if (==f f g) [] (assign res 0)) res))
+ (addraset r 92 (letmut res int 1 (if (!=f f g) [] (assign res 0)) res))
+ (addraset r 93 (letmut res int 1 (if (<f f g) [] (assign res 0)) res))
+ (addraset r 94 (letmut res int 1 (if (>f f g) [] (assign res 0)) res))
+ (addraset r 95 (letmut res int 1 (if (<=f f g) [] (assign res 0)) res))
+ (addraset r 96 (letmut res int 1 (if (>=f f g) [] (assign res 0)) res))
(addraset r 97 (==f (+f f 1.0) (+f g 1.0)))
(addraset r 98 (!=f (+f f 1.0) (+f g 1.0)))
double D[40];
intnat X, Y;
double F, G;
+volatile double H;
#define INTTEST(arg,res) \
{ intnat result = (res); \
#arg, #res, F, G, arg, result); \
}
#define FLOATTEST(arg,res) \
- { double result = (res); \
+ { double result; \
+ H = (res); \
+ result = H; \
if (arg < result || arg > result) \
printf("Failed test \"%s == %s\" for F=%.15g and G=%.15g: "\
"result %.15g, expected %.15g\n", \
(function "quicksort" (lo: int hi: int a: val)
(if (< lo hi)
- (let (i lo
- j hi
- pivot (addraref a hi))
+ (letmut (i int lo
+ j int hi
+ pivot int (addraref a hi))
(while (< i j)
(catch
(while 1
(function "quick" (lo: int hi: int a: val cmp: val)
(if (< lo hi)
- (let (i lo
- j hi
- pivot (intaref a hi))
+ (letmut (i int lo
+ j int hi
+ pivot int (intaref a hi))
(while (< i j)
(catch
(while 1
(if (== (mod (load int "counter") 500) 0)
(extcall "printf_int" "format" (load int "counter") unit)
[])
- (let i 1
+ (letmut i int 1
(while (<= i 7)
- (let j 1
+ (letmut j int 1
(while (<= j 7)
(if (== (intaref (addraref "board" i) j) 2)
(seq
- (let k 0
+ (letmut k int 0
(while (<= k 3)
(let (d1 (intaref (addraref "dir" k) 0)
d2 (intaref (addraref "dir" k) 1)
("format_newline": string "\n\000")
(function "print_board" ()
- (let i 0
+ (letmut i int 0
(while (< i 9)
- (let j 0
+ (letmut j int 0
(while (< j 9)
(switch 3 (intaref (addraref "board" i) j)
case 0:
r))
(function "integr" (f: val low: val high: val n: int)
- (let (h "h" x "x" s "s" i n)
+ (letmut (h val "h" x val "x" s val "s" i int n)
(store float h (/f (-f (load float high) (load float low)) (floatofint n)))
(store float x (load float low))
(store float s 0.0)
(function "quick" (lo: int hi: int a: val)
(if (< lo hi)
- (let (i lo
- j hi
- pivot (addraref a (>>s hi 1)))
+ (letmut (i int lo
+ j int hi
+ pivot int (addraref a (>>s hi 1)))
(while (< i j)
(catch
(while 1
+++ /dev/null
-a
-b
-Fatal error: exception Backtrace.Error("b")
-Raised at file "backtrace.ml", line 16, characters 21-32
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 20, characters 4-11
-Re-raised at file "backtrace.ml", line 22, characters 68-71
-Called from file "backtrace.ml", line 27, characters 9-25
-Fatal error: exception Backtrace.Error("c")
-Raised at file "backtrace.ml", line 23, characters 26-37
-Called from file "backtrace.ml", line 27, characters 9-25
-Fatal error: exception Backtrace.Error("d")
-Raised at file "backtrace.ml", line 16, characters 21-32
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 20, characters 4-11
-Called from file "backtrace.ml", line 27, characters 9-25
-Fatal error: exception Invalid_argument("index out of bounds")
-Raised by primitive operation at file "backtrace.ml", line 27, characters 12-24
(* TEST
flags = "-g"
ocamlrunparam += ",b=1"
- * bytecode
- reference = "${test_source_directory}/backtrace.byte.reference"
- * native
- reference = "${test_source_directory}/backtrace.opt.reference"
- compare_programs = "false"
+ compare_programs = "false"
*)
(* A test for stack backtraces *)
+++ /dev/null
-a
-b
-Fatal error: exception Backtrace.Error("b")
-Raised at file "backtrace.ml", line 16, characters 16-32
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 20, characters 4-11
-Re-raised at file "backtrace.ml", line 22, characters 62-71
-Called from file "backtrace.ml", line 27, characters 9-25
-Fatal error: exception Backtrace.Error("c")
-Raised at file "backtrace.ml", line 23, characters 20-37
-Called from file "backtrace.ml", line 27, characters 9-25
-Fatal error: exception Backtrace.Error("d")
-Raised at file "backtrace.ml", line 16, characters 16-32
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 16, characters 42-53
-Called from file "backtrace.ml", line 20, characters 4-11
-Called from file "backtrace.ml", line 27, characters 9-25
-Fatal error: exception Invalid_argument("index out of bounds")
-Raised by primitive operation at file "backtrace.ml", line 27, characters 12-24
--- /dev/null
+a
+b
+Fatal error: exception Backtrace.Error("b")
+Raised at Backtrace.f in file "backtrace.ml", line 12, characters 16-32
+Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53
+Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53
+Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53
+Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53
+Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53
+Called from Backtrace.g in file "backtrace.ml", line 16, characters 4-11
+Re-raised at Backtrace.g in file "backtrace.ml", line 18, characters 62-71
+Called from Backtrace in file "backtrace.ml", line 23, characters 9-25
+Fatal error: exception Backtrace.Error("c")
+Raised at Backtrace.g in file "backtrace.ml", line 19, characters 20-37
+Called from Backtrace in file "backtrace.ml", line 23, characters 9-25
+Fatal error: exception Backtrace.Error("d")
+Raised at Backtrace.f in file "backtrace.ml", line 12, characters 16-32
+Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53
+Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53
+Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53
+Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53
+Called from Backtrace.f in file "backtrace.ml", line 12, characters 42-53
+Called from Backtrace.g in file "backtrace.ml", line 16, characters 4-11
+Called from Backtrace in file "backtrace.ml", line 23, characters 9-25
+Fatal error: exception Invalid_argument("index out of bounds")
+Raised by primitive operation at Backtrace in file "backtrace.ml", line 23, characters 12-24
+++ /dev/null
-a
-No exception
-b
-Uncaught exception Backtrace2.Error("b")
-Raised at file "backtrace2.ml", line 17, characters 23-34
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 22, characters 4-11
-Re-raised at file "backtrace2.ml", line 24, characters 68-71
-Called from file "backtrace2.ml", line 67, characters 11-23
-Uncaught exception Backtrace2.Error("c")
-Raised at file "backtrace2.ml", line 25, characters 26-37
-Called from file "backtrace2.ml", line 67, characters 11-23
-Uncaught exception Backtrace2.Error("d")
-Raised at file "backtrace2.ml", line 17, characters 23-34
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 22, characters 4-11
-Called from file "backtrace2.ml", line 67, characters 11-23
-e
-Uncaught exception Backtrace2.Error("e")
-Raised at file "backtrace2.ml", line 31, characters 56-59
-Called from file "backtrace2.ml", line 67, characters 11-23
-f
-Uncaught exception Backtrace2.Error("f")
-Raised at file "backtrace2.ml", line 37, characters 68-71
-Called from file "backtrace2.ml", line 67, characters 11-23
-Uncaught exception Invalid_argument("index out of bounds")
-Raised by primitive operation at file "backtrace2.ml", line 67, characters 14-22
-test_Not_found
-Uncaught exception Not_found
-Raised at file "hashtbl.ml", line 537, characters 19-28
-Called from file "backtrace2.ml", line 48, characters 9-42
-Re-raised at file "backtrace2.ml", line 48, characters 67-70
-Called from file "backtrace2.ml", line 67, characters 11-23
-Uncaught exception Not_found
-Raised at file "backtrace2.ml", line 52, characters 24-33
-Called from file "backtrace2.ml", line 52, characters 43-52
-Called from file "backtrace2.ml", line 52, characters 43-52
-Called from file "backtrace2.ml", line 52, characters 43-52
-Called from file "backtrace2.ml", line 52, characters 43-52
-Called from file "backtrace2.ml", line 52, characters 43-52
-Called from file "camlinternalLazy.ml", line 31, characters 17-27
-Re-raised at file "camlinternalLazy.ml", line 36, characters 10-11
-Called from file "backtrace2.ml", line 67, characters 11-23
-Uncaught exception Not_found
-Raised at file "hashtbl.ml", line 537, characters 19-28
-Called from file "backtrace2.ml", line 55, characters 8-41
-Re-raised at file "camlinternalLazy.ml", line 35, characters 62-63
-Called from file "camlinternalLazy.ml", line 31, characters 17-27
-Re-raised at file "camlinternalLazy.ml", line 36, characters 10-11
-Called from file "backtrace2.ml", line 67, characters 11-23
(* TEST
flags = "-g"
ocamlrunparam += ",b=1"
- * bytecode
- reference = "${test_source_directory}/backtrace2.byte.reference"
- * native
- reference = "${test_source_directory}/backtrace2.opt.reference"
- compare_programs = "false"
+ compare_programs = "false"
*)
(* A test for stack backtraces *)
+++ /dev/null
-a
-No exception
-b
-Uncaught exception Backtrace2.Error("b")
-Raised at file "backtrace2.ml", line 17, characters 18-34
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 22, characters 4-11
-Re-raised at file "backtrace2.ml", line 24, characters 62-71
-Called from file "backtrace2.ml", line 67, characters 11-23
-Uncaught exception Backtrace2.Error("c")
-Raised at file "backtrace2.ml", line 25, characters 20-37
-Called from file "backtrace2.ml", line 67, characters 11-23
-Uncaught exception Backtrace2.Error("d")
-Raised at file "backtrace2.ml", line 17, characters 18-34
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 17, characters 44-55
-Called from file "backtrace2.ml", line 22, characters 4-11
-Called from file "backtrace2.ml", line 67, characters 11-23
-e
-Uncaught exception Backtrace2.Error("e")
-Raised at file "backtrace2.ml", line 31, characters 50-59
-Called from file "backtrace2.ml", line 67, characters 11-23
-f
-Uncaught exception Backtrace2.Error("f")
-Raised at file "backtrace2.ml", line 37, characters 62-71
-Called from file "backtrace2.ml", line 67, characters 11-23
-Uncaught exception Invalid_argument("index out of bounds")
-Raised by primitive operation at file "backtrace2.ml", line 67, characters 14-22
-test_Not_found
-Uncaught exception Not_found
-Raised at file "hashtbl.ml", line 537, characters 13-28
-Called from file "backtrace2.ml", line 48, characters 9-42
-Re-raised at file "backtrace2.ml", line 48, characters 61-70
-Called from file "backtrace2.ml", line 67, characters 11-23
-Uncaught exception Not_found
-Raised at file "backtrace2.ml", line 52, characters 18-33
-Called from file "backtrace2.ml", line 52, characters 43-52
-Called from file "backtrace2.ml", line 52, characters 43-52
-Called from file "backtrace2.ml", line 52, characters 43-52
-Called from file "backtrace2.ml", line 52, characters 43-52
-Called from file "backtrace2.ml", line 52, characters 43-52
-Called from file "camlinternalLazy.ml", line 31, characters 17-27
-Re-raised at file "camlinternalLazy.ml", line 36, characters 4-11
-Called from file "backtrace2.ml", line 67, characters 11-23
-Uncaught exception Not_found
-Raised at file "hashtbl.ml", line 537, characters 13-28
-Called from file "backtrace2.ml", line 55, characters 8-41
-Re-raised at file "camlinternalLazy.ml", line 35, characters 56-63
-Called from file "camlinternalLazy.ml", line 31, characters 17-27
-Re-raised at file "camlinternalLazy.ml", line 36, characters 4-11
-Called from file "backtrace2.ml", line 67, characters 11-23
--- /dev/null
+a
+No exception
+b
+Uncaught exception Backtrace2.Error("b")
+Raised at Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 18-34
+Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55
+Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55
+Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55
+Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55
+Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55
+Called from Backtrace2.test_Error in file "backtrace2.ml", line 18, characters 4-11
+Re-raised at Backtrace2.test_Error in file "backtrace2.ml", line 20, characters 62-71
+Called from Backtrace2.run in file "backtrace2.ml", line 63, characters 11-23
+Uncaught exception Backtrace2.Error("c")
+Raised at Backtrace2.test_Error in file "backtrace2.ml", line 21, characters 20-37
+Called from Backtrace2.run in file "backtrace2.ml", line 63, characters 11-23
+Uncaught exception Backtrace2.Error("d")
+Raised at Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 18-34
+Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55
+Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55
+Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55
+Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55
+Called from Backtrace2.test_Error.f in file "backtrace2.ml", line 13, characters 44-55
+Called from Backtrace2.test_Error in file "backtrace2.ml", line 18, characters 4-11
+Called from Backtrace2.run in file "backtrace2.ml", line 63, characters 11-23
+e
+Uncaught exception Backtrace2.Error("e")
+Raised at Backtrace2.test_Error in file "backtrace2.ml", line 27, characters 50-59
+Called from Backtrace2.run in file "backtrace2.ml", line 63, characters 11-23
+f
+Uncaught exception Backtrace2.Error("f")
+Raised at Backtrace2.test_Error in file "backtrace2.ml", line 33, characters 62-71
+Called from Backtrace2.run in file "backtrace2.ml", line 63, characters 11-23
+Uncaught exception Invalid_argument("index out of bounds")
+Raised by primitive operation at Backtrace2.run in file "backtrace2.ml", line 63, characters 14-22
+test_Not_found
+Uncaught exception Not_found
+Raised at Stdlib__hashtbl.find in file "hashtbl.ml", line 537, characters 13-28
+Called from Backtrace2.test_Not_found in file "backtrace2.ml", line 44, characters 9-42
+Re-raised at Backtrace2.test_Not_found in file "backtrace2.ml", line 44, characters 61-70
+Called from Backtrace2.run in file "backtrace2.ml", line 63, characters 11-23
+Uncaught exception Not_found
+Raised at Backtrace2.test_lazy.aux in file "backtrace2.ml", line 48, characters 18-33
+Called from Backtrace2.test_lazy.aux in file "backtrace2.ml", line 48, characters 43-52
+Called from Backtrace2.test_lazy.aux in file "backtrace2.ml", line 48, characters 43-52
+Called from Backtrace2.test_lazy.aux in file "backtrace2.ml", line 48, characters 43-52
+Called from Backtrace2.test_lazy.aux in file "backtrace2.ml", line 48, characters 43-52
+Called from Backtrace2.test_lazy.aux in file "backtrace2.ml", line 48, characters 43-52
+Called from CamlinternalLazy.force_lazy_block in file "camlinternalLazy.ml", line 31, characters 17-27
+Re-raised at CamlinternalLazy.force_lazy_block in file "camlinternalLazy.ml", line 36, characters 4-11
+Called from Backtrace2.run in file "backtrace2.ml", line 63, characters 11-23
+Uncaught exception Not_found
+Raised at Stdlib__hashtbl.find in file "hashtbl.ml", line 537, characters 13-28
+Called from Backtrace2.test_lazy.exception_raised_internally in file "backtrace2.ml", line 51, characters 8-41
+Re-raised at CamlinternalLazy.force_lazy_block.(fun) in file "camlinternalLazy.ml", line 35, characters 56-63
+Called from CamlinternalLazy.force_lazy_block in file "camlinternalLazy.ml", line 31, characters 17-27
+Re-raised at CamlinternalLazy.force_lazy_block in file "camlinternalLazy.ml", line 36, characters 4-11
+Called from Backtrace2.run in file "backtrace2.ml", line 63, characters 11-23
+++ /dev/null
-a
-No exception
-b
-Uncaught exception Backtrace3.Error("b")
-Raised at file "backtrace3.ml", line 16, characters 21-32
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 20, characters 4-11
-Re-raised at file "backtrace3.ml", line 29, characters 47-50
-Called from file "backtrace3.ml", line 54, characters 11-23
-c
-Uncaught exception Backtrace3.Error("c")
-Raised at file "backtrace3.ml", line 33, characters 47-58
-Called from file "backtrace3.ml", line 54, characters 11-23
-d
-Uncaught exception Backtrace3.Error("d")
-Raised at file "backtrace3.ml", line 16, characters 21-32
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 20, characters 4-11
-Re-raised at file "backtrace3.ml", line 36, characters 47-50
-Called from file "backtrace3.ml", line 54, characters 11-23
-e
-Uncaught exception Backtrace3.Error("e")
-Raised at file "backtrace3.ml", line 16, characters 21-32
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 20, characters 4-11
-Re-raised at file "backtrace3.ml", line 39, characters 47-51
-Called from file "backtrace3.ml", line 54, characters 11-23
-f
-Uncaught exception Backtrace3.Error("f")
-Raised at file "backtrace3.ml", line 16, characters 21-32
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 20, characters 4-11
-Re-raised at file "backtrace3.ml", line 44, characters 51-54
-Called from file "backtrace3.ml", line 54, characters 11-23
-g
-Uncaught exception Backtrace3.Error("g")
-Raised at file "backtrace3.ml", line 16, characters 21-32
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 20, characters 4-11
-Re-raised at file "backtrace3.ml", line 47, characters 51-55
-Called from file "backtrace3.ml", line 54, characters 11-23
-Uncaught exception Backtrace3.Error("h")
-Raised at file "backtrace3.ml", line 50, characters 16-17
-Called from file "backtrace3.ml", line 54, characters 11-23
-Uncaught exception Invalid_argument("index out of bounds")
-Raised by primitive operation at file "backtrace3.ml", line 54, characters 14-22
(* TEST
flags = "-g"
ocamlrunparam += ",b=1"
- * bytecode
- reference = "${test_source_directory}/backtrace3.byte.reference"
- * native
- reference = "${test_source_directory}/backtrace3.opt.reference"
- compare_programs = "false"
+ compare_programs = "false"
*)
(* A test for stack backtraces *)
+++ /dev/null
-a
-No exception
-b
-Uncaught exception Backtrace3.Error("b")
-Raised at file "backtrace3.ml", line 16, characters 16-32
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 20, characters 4-11
-Re-raised at file "backtrace3.ml", line 29, characters 41-50
-Called from file "backtrace3.ml", line 54, characters 11-23
-c
-Uncaught exception Backtrace3.Error("c")
-Raised at file "backtrace3.ml", line 33, characters 41-58
-Called from file "backtrace3.ml", line 54, characters 11-23
-d
-Uncaught exception Backtrace3.Error("d")
-Raised at file "backtrace3.ml", line 16, characters 16-32
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 20, characters 4-11
-Re-raised at file "backtrace3.ml", line 36, characters 41-50
-Called from file "backtrace3.ml", line 54, characters 11-23
-e
-Uncaught exception Backtrace3.Error("e")
-Raised at file "backtrace3.ml", line 16, characters 16-32
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 20, characters 4-11
-Re-raised at file "backtrace3.ml", line 39, characters 41-51
-Called from file "backtrace3.ml", line 54, characters 11-23
-f
-Uncaught exception Backtrace3.Error("f")
-Raised at file "backtrace3.ml", line 16, characters 16-32
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 20, characters 4-11
-Re-raised at file "backtrace3.ml", line 44, characters 45-54
-Called from file "backtrace3.ml", line 54, characters 11-23
-g
-Uncaught exception Backtrace3.Error("g")
-Raised at file "backtrace3.ml", line 16, characters 16-32
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 16, characters 42-53
-Called from file "backtrace3.ml", line 20, characters 4-11
-Re-raised at file "backtrace3.ml", line 47, characters 45-55
-Called from file "backtrace3.ml", line 54, characters 11-23
-Uncaught exception Backtrace3.Error("h")
-Raised at file "backtrace3.ml", line 50, characters 10-17
-Called from file "backtrace3.ml", line 54, characters 11-23
-Uncaught exception Invalid_argument("index out of bounds")
-Raised by primitive operation at file "backtrace3.ml", line 54, characters 14-22
--- /dev/null
+a
+No exception
+b
+Uncaught exception Backtrace3.Error("b")
+Raised at Backtrace3.f in file "backtrace3.ml", line 12, characters 16-32
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.g in file "backtrace3.ml", line 16, characters 4-11
+Re-raised at Backtrace3.g in file "backtrace3.ml", line 25, characters 41-50
+Called from Backtrace3.run in file "backtrace3.ml", line 50, characters 11-23
+c
+Uncaught exception Backtrace3.Error("c")
+Raised at Backtrace3.g in file "backtrace3.ml", line 29, characters 41-58
+Called from Backtrace3.run in file "backtrace3.ml", line 50, characters 11-23
+d
+Uncaught exception Backtrace3.Error("d")
+Raised at Backtrace3.f in file "backtrace3.ml", line 12, characters 16-32
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.g in file "backtrace3.ml", line 16, characters 4-11
+Re-raised at Backtrace3.g in file "backtrace3.ml", line 32, characters 41-50
+Called from Backtrace3.run in file "backtrace3.ml", line 50, characters 11-23
+e
+Uncaught exception Backtrace3.Error("e")
+Raised at Backtrace3.f in file "backtrace3.ml", line 12, characters 16-32
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.g in file "backtrace3.ml", line 16, characters 4-11
+Re-raised at Backtrace3.g in file "backtrace3.ml", line 35, characters 41-51
+Called from Backtrace3.run in file "backtrace3.ml", line 50, characters 11-23
+f
+Uncaught exception Backtrace3.Error("f")
+Raised at Backtrace3.f in file "backtrace3.ml", line 12, characters 16-32
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.g in file "backtrace3.ml", line 16, characters 4-11
+Re-raised at Backtrace3.g in file "backtrace3.ml", line 40, characters 45-54
+Called from Backtrace3.run in file "backtrace3.ml", line 50, characters 11-23
+g
+Uncaught exception Backtrace3.Error("g")
+Raised at Backtrace3.f in file "backtrace3.ml", line 12, characters 16-32
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.f in file "backtrace3.ml", line 12, characters 42-53
+Called from Backtrace3.g in file "backtrace3.ml", line 16, characters 4-11
+Re-raised at Backtrace3.g in file "backtrace3.ml", line 43, characters 45-55
+Called from Backtrace3.run in file "backtrace3.ml", line 50, characters 11-23
+Uncaught exception Backtrace3.Error("h")
+Raised at Backtrace3.g in file "backtrace3.ml", line 46, characters 10-17
+Called from Backtrace3.run in file "backtrace3.ml", line 50, characters 11-23
+Uncaught exception Invalid_argument("index out of bounds")
+Raised by primitive operation at Backtrace3.run in file "backtrace3.ml", line 50, characters 14-22
+++ /dev/null
-a
-No exception
-b
-Uncaught exception Backtrace_deprecated.Error("b")
-Raised at file "backtrace_deprecated.ml", line 19, characters 21-32
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 23, characters 4-11
-Re-raised at file "backtrace_deprecated.ml", line 25, characters 68-71
-Called from file "backtrace_deprecated.ml", line 30, characters 11-23
-Uncaught exception Backtrace_deprecated.Error("c")
-Raised at file "backtrace_deprecated.ml", line 26, characters 26-37
-Called from file "backtrace_deprecated.ml", line 30, characters 11-23
-Uncaught exception Backtrace_deprecated.Error("d")
-Raised at file "backtrace_deprecated.ml", line 19, characters 21-32
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 23, characters 4-11
-Called from file "backtrace_deprecated.ml", line 30, characters 11-23
-Uncaught exception Invalid_argument("index out of bounds")
-Raised by primitive operation at file "backtrace_deprecated.ml", line 30, characters 14-22
(* TEST
flags = "-g"
ocamlrunparam += ",b=1"
- * bytecode
- reference = "${test_source_directory}/backtrace_deprecated.byte.reference"
- * native
- reference = "${test_source_directory}/backtrace_deprecated.opt.reference"
- compare_programs = "false"
+ compare_programs = "false"
*)
(* A test for stack backtraces *)
+++ /dev/null
-a
-No exception
-b
-Uncaught exception Backtrace_deprecated.Error("b")
-Raised at file "backtrace_deprecated.ml", line 19, characters 16-32
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 23, characters 4-11
-Re-raised at file "backtrace_deprecated.ml", line 25, characters 62-71
-Called from file "backtrace_deprecated.ml", line 30, characters 11-23
-Uncaught exception Backtrace_deprecated.Error("c")
-Raised at file "backtrace_deprecated.ml", line 26, characters 20-37
-Called from file "backtrace_deprecated.ml", line 30, characters 11-23
-Uncaught exception Backtrace_deprecated.Error("d")
-Raised at file "backtrace_deprecated.ml", line 19, characters 16-32
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 19, characters 42-53
-Called from file "backtrace_deprecated.ml", line 23, characters 4-11
-Called from file "backtrace_deprecated.ml", line 30, characters 11-23
-Uncaught exception Invalid_argument("index out of bounds")
-Raised by primitive operation at file "backtrace_deprecated.ml", line 30, characters 14-22
--- /dev/null
+a
+No exception
+b
+Uncaught exception Backtrace_deprecated.Error("b")
+Raised at Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 16-32
+Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53
+Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53
+Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53
+Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53
+Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53
+Called from Backtrace_deprecated.g in file "backtrace_deprecated.ml", line 19, characters 4-11
+Re-raised at Backtrace_deprecated.g in file "backtrace_deprecated.ml", line 21, characters 62-71
+Called from Backtrace_deprecated.run in file "backtrace_deprecated.ml", line 26, characters 11-23
+Uncaught exception Backtrace_deprecated.Error("c")
+Raised at Backtrace_deprecated.g in file "backtrace_deprecated.ml", line 22, characters 20-37
+Called from Backtrace_deprecated.run in file "backtrace_deprecated.ml", line 26, characters 11-23
+Uncaught exception Backtrace_deprecated.Error("d")
+Raised at Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 16-32
+Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53
+Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53
+Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53
+Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53
+Called from Backtrace_deprecated.f in file "backtrace_deprecated.ml", line 15, characters 42-53
+Called from Backtrace_deprecated.g in file "backtrace_deprecated.ml", line 19, characters 4-11
+Called from Backtrace_deprecated.run in file "backtrace_deprecated.ml", line 26, characters 11-23
+Uncaught exception Invalid_argument("index out of bounds")
+Raised by primitive operation at Backtrace_deprecated.run in file "backtrace_deprecated.ml", line 26, characters 14-22
+++ /dev/null
-exception Backtrace_or_exception.Exn
-Raised at file "backtrace_or_exception.ml", line 24, characters 10-13
-Called from file "backtrace_or_exception.ml", line 44, characters 6-10
----------------------------
-exception Backtrace_or_exception.Exn
-Raised at file "backtrace_or_exception.ml", line 15, characters 10-13
-Called from file "backtrace_or_exception.ml", line 28, characters 8-44
-Re-raised at file "backtrace_or_exception.ml", line 31, characters 10-13
-Called from file "backtrace_or_exception.ml", line 44, characters 6-10
----------------------------
-exception Backtrace_or_exception.Exn
-Raised at file "backtrace_or_exception.ml", line 40, characters 12-15
-Called from file "backtrace_or_exception.ml", line 44, characters 6-10
----------------------------
(* TEST
flags = "-g"
ocamlrunparam += ",b=1"
- * bytecode
- reference="${test_source_directory}/backtrace_or_exception.byte.reference"
- * native
- reference = "${test_source_directory}/backtrace_or_exception.opt.reference"
- compare_programs = "false"
+ compare_programs = "false"
*)
exception Exn
+++ /dev/null
-exception Backtrace_or_exception.Exn
-Raised at file "backtrace_or_exception.ml", line 24, characters 4-13
-Called from file "backtrace_or_exception.ml", line 44, characters 6-10
----------------------------
-exception Backtrace_or_exception.Exn
-Raised at file "backtrace_or_exception.ml", line 15, characters 4-13
-Called from file "backtrace_or_exception.ml", line 28, characters 8-44
-Re-raised at file "backtrace_or_exception.ml", line 31, characters 4-13
-Called from file "backtrace_or_exception.ml", line 44, characters 6-10
----------------------------
-exception Backtrace_or_exception.Exn
-Raised at file "backtrace_or_exception.ml", line 40, characters 6-15
-Called from file "backtrace_or_exception.ml", line 44, characters 6-10
----------------------------
--- /dev/null
+exception Backtrace_or_exception.Exn
+Raised at Backtrace_or_exception.without_reraise in file "backtrace_or_exception.ml", line 20, characters 4-13
+Called from Backtrace_or_exception.run in file "backtrace_or_exception.ml", line 40, characters 6-10
+---------------------------
+exception Backtrace_or_exception.Exn
+Raised at Backtrace_or_exception.return_exn in file "backtrace_or_exception.ml", line 11, characters 4-13
+Called from Backtrace_or_exception.with_reraise in file "backtrace_or_exception.ml", line 24, characters 8-44
+Re-raised at Backtrace_or_exception.with_reraise in file "backtrace_or_exception.ml", line 27, characters 4-13
+Called from Backtrace_or_exception.run in file "backtrace_or_exception.ml", line 40, characters 6-10
+---------------------------
+exception Backtrace_or_exception.Exn
+Raised at Backtrace_or_exception.trickier in file "backtrace_or_exception.ml", line 36, characters 6-15
+Called from Backtrace_or_exception.run in file "backtrace_or_exception.ml", line 40, characters 6-10
+---------------------------
+++ /dev/null
-a
-No exception
-b
-Uncaught exception Backtrace_slots.Error("b")
-Raised at file "backtrace_slots.ml", line 45, characters 21-32
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 49, characters 4-11
-Re-raised at file "backtrace_slots.ml", line 51, characters 68-71
-Called from file "backtrace_slots.ml", line 56, characters 11-23
-Uncaught exception Backtrace_slots.Error("c")
-Raised at file "backtrace_slots.ml", line 52, characters 26-37
-Called from file "backtrace_slots.ml", line 56, characters 11-23
-Uncaught exception Backtrace_slots.Error("d")
-Raised at file "backtrace_slots.ml", line 45, characters 21-32
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 49, characters 4-11
-Called from file "backtrace_slots.ml", line 56, characters 11-23
-Uncaught exception Invalid_argument("index out of bounds")
-Raised by primitive operation at file "backtrace_slots.ml", line 56, characters 14-22
(* TEST
flags = "-g"
ocamlrunparam += ",b=1"
- * bytecode
- reference = "${test_source_directory}/backtrace_slots.byte.reference"
- * native
- reference = "${test_source_directory}/backtrace_slots.opt.reference"
- compare_programs = "false"
+ compare_programs = "false"
*)
(* A test for stack backtraces *)
+++ /dev/null
-a
-No exception
-b
-Uncaught exception Backtrace_slots.Error("b")
-Raised at file "backtrace_slots.ml", line 45, characters 16-32
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 49, characters 4-11
-Re-raised at file "backtrace_slots.ml", line 51, characters 62-71
-Called from file "backtrace_slots.ml", line 56, characters 11-23
-Uncaught exception Backtrace_slots.Error("c")
-Raised at file "backtrace_slots.ml", line 52, characters 20-37
-Called from file "backtrace_slots.ml", line 56, characters 11-23
-Uncaught exception Backtrace_slots.Error("d")
-Raised at file "backtrace_slots.ml", line 45, characters 16-32
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 45, characters 42-53
-Called from file "backtrace_slots.ml", line 49, characters 4-11
-Called from file "backtrace_slots.ml", line 56, characters 11-23
-Uncaught exception Invalid_argument("index out of bounds")
-Raised by primitive operation at file "backtrace_slots.ml", line 56, characters 14-22
--- /dev/null
+a
+No exception
+b
+Uncaught exception Backtrace_slots.Error("b")
+Raised at Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 16-32
+Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53
+Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53
+Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53
+Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53
+Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53
+Called from Backtrace_slots.g in file "backtrace_slots.ml", line 45, characters 4-11
+Re-raised at Backtrace_slots.g in file "backtrace_slots.ml", line 47, characters 62-71
+Called from Backtrace_slots.run in file "backtrace_slots.ml", line 52, characters 11-23
+Uncaught exception Backtrace_slots.Error("c")
+Raised at Backtrace_slots.g in file "backtrace_slots.ml", line 48, characters 20-37
+Called from Backtrace_slots.run in file "backtrace_slots.ml", line 52, characters 11-23
+Uncaught exception Backtrace_slots.Error("d")
+Raised at Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 16-32
+Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53
+Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53
+Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53
+Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53
+Called from Backtrace_slots.f in file "backtrace_slots.ml", line 41, characters 42-53
+Called from Backtrace_slots.g in file "backtrace_slots.ml", line 45, characters 4-11
+Called from Backtrace_slots.run in file "backtrace_slots.ml", line 52, characters 11-23
+Uncaught exception Invalid_argument("index out of bounds")
+Raised by primitive operation at Backtrace_slots.run in file "backtrace_slots.ml", line 52, characters 14-22
include systhreads
compare_programs = "false"
** no-flambda
- reference = "${test_source_directory}/callstack.reference"
*** native
*** bytecode
*)
+
let[@inline never] f0 () =
Printexc.print_raw_backtrace stdout (Printexc.get_callstack 100); ()
let[@inline never] f1 () = f0 (); ()
let[@inline never] f2 () = f1 (); ()
let[@inline never] f3 () = f2 (); ()
+
let () = Printf.printf "main thread:\n"
let () = f3 ()
-let () = Printf.printf "new thread:\n"
-let () = Thread.join (Thread.create f3 ())
+let () = Printf.printf "from finalizer:\n"
let () =
Gc.finalise (fun _ -> f0 ()) [|1|];
Gc.full_major ();
()
+
+(* We run this last, because the initialization of the thread library
+ starts the "tick thread", which periodically send a signal for
+ thread preemption. If the preempion occurs exactly when the
+ finalizer above runs, then a new row for [Thread.yield] appears in
+ the callstack, which breaks the test. *)
+let () = Printf.printf "new thread:\n"
+let () = Thread.join (Thread.create f3 ())
main thread:
-Raised by primitive operation at file "callstack.ml", line 12, characters 38-66
-Called from file "callstack.ml", line 13, characters 27-32
-Called from file "callstack.ml", line 14, characters 27-32
-Called from file "callstack.ml", line 15, characters 27-32
-Called from file "callstack.ml", line 17, characters 9-14
+Raised by primitive operation at Callstack.f0 in file "callstack.ml", line 12, characters 38-66
+Called from Callstack.f1 in file "callstack.ml", line 13, characters 27-32
+Called from Callstack.f2 in file "callstack.ml", line 14, characters 27-32
+Called from Callstack.f3 in file "callstack.ml", line 15, characters 27-32
+Called from Callstack in file "callstack.ml", line 18, characters 9-14
+from finalizer:
+Raised by primitive operation at Callstack.f0 in file "callstack.ml", line 12, characters 38-66
+Called from Callstack in file "callstack.ml", line 23, characters 2-18
new thread:
-Raised by primitive operation at file "callstack.ml", line 12, characters 38-66
-Called from file "callstack.ml", line 13, characters 27-32
-Called from file "callstack.ml", line 14, characters 27-32
-Called from file "callstack.ml", line 15, characters 27-32
-Called from file "thread.ml", line 39, characters 8-14
-Raised by primitive operation at file "callstack.ml", line 12, characters 38-66
-Called from file "callstack.ml", line 23, characters 2-18
+Raised by primitive operation at Callstack.f0 in file "callstack.ml", line 12, characters 38-66
+Called from Callstack.f1 in file "callstack.ml", line 13, characters 27-32
+Called from Callstack.f2 in file "callstack.ml", line 14, characters 27-32
+Called from Callstack.f3 in file "callstack.ml", line 15, characters 27-32
+Called from Thread.create.(fun) in file "thread.ml", line 39, characters 8-14
--- /dev/null
+(* TEST
+ flags = "-g"
+ compare_programs = "false" *)
+
+let f n b =
+ let arr = Array.make n 42 in
+ if b then (arr, [| |]) else ([| |], arr)
+
+let () =
+ Printexc.record_backtrace true;
+ match Sys.opaque_identity f (-1) true with
+ | _ -> assert false
+ | exception _ ->
+ Printexc.print_backtrace stdout
--- /dev/null
+Raised by primitive operation at Event_after_prim.f in file "event_after_prim.ml", line 6, characters 12-27
+Called from Event_after_prim in file "event_after_prim.ml", line 11, characters 8-39
+++ /dev/null
-inline_test.ml
-line 19
-characters 8-24
-inline_test.ml
-line 22
-characters 2-5
-inline_test.ml
-line 25
-characters 12-17
-inline_test.ml
-line 28
-characters 5-8
-inline_test.ml
-line 32
-characters 2-6
flags = "-g"
ocamlrunparam += ",b=1"
* bytecode
- reference = "${test_source_directory}/inline_test.byte.reference"
* native
- reference = "${test_source_directory}/inline_test.opt.reference"
compare_programs = "false"
* native
ocamlopt_flags = "-O3"
compiler_directory_suffix = ".O3"
- reference = "${test_source_directory}/inline_test.opt.reference"
compare_programs = "false"
*)
+++ /dev/null
-inline_test.ml
-line 19
-characters 2-24
-inline_test.ml
-line 22
-characters 2-5
-inline_test.ml
-line 25
-characters 12-17
-inline_test.ml
-line 28
-characters 5-8
-inline_test.ml
-line 32
-characters 2-6
--- /dev/null
+inline_test.ml
+line 16
+characters 2-24
+inline_test.ml
+line 19
+characters 2-5
+inline_test.ml
+line 22
+characters 12-17
+inline_test.ml
+line 25
+characters 5-8
+inline_test.ml
+line 29
+characters 2-6
+++ /dev/null
-inline_traversal_test.ml:19
-inline_traversal_test.ml:22
-inline_traversal_test.ml:25
-inline_traversal_test.ml:28
-inline_traversal_test.ml:33
flags = "-g"
ocamlrunparam += ",b=1"
* bytecode
- reference = "${test_source_directory}/inline_traversal_test.byte.reference"
* native
- reference = "${test_source_directory}/inline_traversal_test.opt.reference"
compare_programs = "false"
* native
ocamlopt_flags = "-O3"
compiler_directory_suffix = ".O3"
- reference = "${test_source_directory}/inline_traversal_test.opt.reference"
compare_programs = "false"
*)
+++ /dev/null
-inline_traversal_test.ml:19
-inline_traversal_test.ml:22
-inline_traversal_test.ml:25
-inline_traversal_test.ml:28
-inline_traversal_test.ml:33
--- /dev/null
+inline_traversal_test.ml:16
+inline_traversal_test.ml:19
+inline_traversal_test.ml:22
+inline_traversal_test.ml:25
+inline_traversal_test.ml:30
--- /dev/null
+(* TEST
+ flags = "-g"
+ compare_programs = "false" *)
+
+let[@inline never] id x = Sys.opaque_identity x
+
+class foo = object (self)
+ val other = new bar "asdf"
+ method go : unit =
+ id (other#go 1 2 3)
+end
+and bar _v = object (self)
+ method go _ _ _ : unit =
+ id (self#bang)
+ method bang : unit =
+ raise Exit
+end
+
+let () =
+ Printexc.record_backtrace true;
+ let obj = object (self)
+ method meth : unit =
+ id ((new foo)#go)
+ end in
+ match obj#meth with
+ | _ -> assert false
+ | exception Exit ->
+ Printexc.print_backtrace stdout
--- /dev/null
+Raised at Methods.bar#bang in file "methods.ml", line 16, characters 4-14
+Called from Methods.bar#go in file "methods.ml", line 14, characters 7-18
+Called from Methods.foo#go in file "methods.ml", line 10, characters 7-23
+Called from Methods.object#meth in file "methods.ml", line 23, characters 9-23
+Called from Methods in file "methods.ml", line 25, characters 8-16
--- /dev/null
+(* TEST
+ flags = "-g"
+ compare_programs = "false"
+ *)
+
+
+let id x = Sys.opaque_identity x
+
+let[@inline never] bang () = raise Exit
+
+
+let[@inline never] fn_multi _ _ f = f 42 + 1
+
+let[@inline never] fn_function = function
+ | f -> f 42 + 1
+
+let[@inline never] fn_poly : 'a . 'a -> ('a -> int) -> int = fun x f ->
+ f x + 1
+
+module Mod1 = struct
+ module Nested = struct
+ let[@inline never] apply f = f 42 + 1
+ end
+end
+
+let[@inline never] anon f =
+ let fn = id (fun () -> f 42 + 1) in
+ fn ()
+
+let[@inline never] double_anon f =
+ let fn = id (fun () ->
+ let fn = id (fun () ->
+ f 42 + 1) in
+ fn ()) in
+ fn ()
+
+let[@inline never] local f =
+ let[@inline never] inner () = f 42 + 1 in
+ (id inner) () + 1
+
+let[@inline never] double_local f =
+ let inner1 () =
+ let inner2 () = f 42 + 1 in
+ (id inner2) () + 1 in
+ (id inner1) () + 1
+
+let local_no_arg =
+ let inner f = f 42 + 1 in
+ fun[@inline never] f -> (id inner) f + 1
+
+let[@inline never] curried () =
+ let inner () f = f 42 in
+ id (inner ())
+
+let[@inline never] local_module f =
+ let module N = struct
+ let[@inline never] foo () =
+ f 42 + 1
+ let r = ref 0 let () = r := id (id foo ())
+ end in
+ !N.r
+
+module Functor (X : sig end) = struct
+ let[@inline never] fn f = f 42 + 1
+end
+module Inst = Functor (struct end)
+
+module rec Rec1 : sig
+ val fn : (int -> int) -> int
+end = struct
+ module M = Rec2 (struct end)
+ let[@inline never] fn f = M.fn f + 1
+end
+and Rec2 : functor (X : sig end) -> sig
+ val fn : (int -> int) -> int
+end = functor (X : sig end) -> struct
+ let[@inline never] fn f = f 42 + 1
+end
+
+let[@inline never] (+@+) n f = f 42 + 1
+
+class klass = object (self)
+ val other = new klass2 "asdf"
+ method meth f : int =
+ other#othermeth 1 1 f 1 + 1
+end
+and klass2 _v = object (self)
+ method othermeth _ _ f _ =
+ (id (fun g -> g 42 + 1) f) + 1
+end
+
+let inline_object f =
+ let obj = object (self)
+ method meth : int =
+ self#othermeth 1 f 1 + 1
+ method othermeth _ _ _ =
+ f 42 + 1
+ end in
+ obj#meth
+
+let () =
+ Printexc.record_backtrace true;
+ match
+ fn_multi 1 1 @@ fun _ ->
+ fn_function @@ fun _ ->
+ fn_poly 42 @@ fun _ ->
+ Mod1.Nested.apply @@ fun _ ->
+ anon @@ fun _ ->
+ double_anon @@ fun _ ->
+ local @@ fun _ ->
+ double_local @@ fun _ ->
+ local_no_arg @@ fun _ ->
+ curried () @@ fun _ ->
+ local_module @@ fun _ ->
+ Inst.fn @@ fun _ ->
+ Rec1.fn @@ fun _ ->
+ 42 +@+ fun _ ->
+ (new klass)#meth @@ fun _ ->
+ inline_object @@ fun _ ->
+ bang ()
+ with
+ | _ -> assert false
+ | exception Exit ->
+ Printexc.print_backtrace stdout
--- /dev/null
+Raised at Names.bang in file "names.ml", line 9, characters 29-39
+Called from Names.inline_object.object#othermeth in file "names.ml", line 97, characters 6-10
+Called from Names.inline_object.object#meth in file "names.ml", line 95, characters 6-26
+Called from Names.klass2#othermeth.(fun) in file "names.ml", line 89, characters 18-22
+Called from Names.klass2#othermeth in file "names.ml", line 89, characters 4-30
+Called from Names.klass#meth in file "names.ml", line 85, characters 4-27
+Called from Names.(+@+) in file "names.ml", line 80, characters 31-35
+Called from Names.Rec2.fn in file "names.ml", line 77, characters 28-32
+Called from Names.Rec1.fn in file "names.ml", line 72, characters 28-34
+Called from Names.Functor.fn in file "names.ml", line 64, characters 28-32
+Called from Names.local_module.N.foo in file "names.ml", line 58, characters 6-10
+Called from Names.local_module.N in file "names.ml", line 59, characters 38-49
+Called from Names.local_no_arg.inner in file "names.ml", line 48, characters 16-20
+Called from Names.local_no_arg.(fun) in file "names.ml", line 49, characters 26-38
+Called from Names.double_local.inner1.inner2 in file "names.ml", line 43, characters 20-24
+Called from Names.double_local.inner1 in file "names.ml", line 44, characters 4-18
+Called from Names.double_local in file "names.ml", line 45, characters 2-16
+Called from Names.local.inner in file "names.ml", line 38, characters 32-36
+Called from Names.local in file "names.ml", line 39, characters 2-15
+Called from Names.double_anon.(fun) in file "names.ml", line 33, characters 6-10
+Called from Names.anon.(fun) in file "names.ml", line 27, characters 25-29
+Called from Names.Mod1.Nested.apply in file "names.ml", line 22, characters 33-37
+Called from Names.fn_poly in file "names.ml", line 18, characters 2-5
+Called from Names.fn_function in file "names.ml", line 15, characters 9-13
+Called from Names.fn_multi in file "names.ml", line 12, characters 36-40
+Called from Names in file "names.ml", line 104, characters 4-445
+++ /dev/null
-Fatal error: exception Stdlib.Exit
-Raised at file "pr6920_why_at.ml", line 13, characters 41-45
-Called from file "pr6920_why_at.ml", line 15, characters 2-11
-Called from file "pr6920_why_at.ml", line 21, characters 2-6
ocamlrunparam += ",b=1"
ocamlopt_flags = "-inline 0"
exit_status = "2"
- * bytecode
- reference = "${test_source_directory}/pr6920_why_at.byte.reference"
- * native
- reference = "${test_source_directory}/pr6920_why_at.opt.reference"
- compare_programs = "false"
+ compare_programs = "false"
*)
let why : unit -> unit = fun () -> raise Exit [@@inline never]
+++ /dev/null
-Fatal error: exception Stdlib.Exit
-Raised at file "pr6920_why_at.ml", line 13, characters 35-45
-Called from file "pr6920_why_at.ml", line 15, characters 2-11
-Called from file "pr6920_why_at.ml", line 21, characters 2-6
--- /dev/null
+Fatal error: exception Stdlib.Exit
+Raised at Pr6920_why_at.why in file "pr6920_why_at.ml", line 9, characters 35-45
+Called from Pr6920_why_at.f in file "pr6920_why_at.ml", line 11, characters 2-11
+Called from Pr6920_why_at in file "pr6920_why_at.ml", line 17, characters 2-6
+++ /dev/null
-Fatal error: exception Stdlib.Exit
-Raised at file "pr6920_why_swallow.ml", line 13, characters 41-45
-Called from file "pr6920_why_swallow.ml", line 16, characters 4-13
-Called from file "pr6920_why_swallow.ml", line 23, characters 2-6
ocamlrunparam += ",b=1"
ocamlopt_flags = "-inline 0"
exit_status = "2"
- * bytecode
- reference = "${test_source_directory}/pr6920_why_swallow.byte.reference"
- * native
- reference = "${test_source_directory}/pr6920_why_swallow.opt.reference"
- compare_programs = "false"
+ compare_programs = "false"
*)
let why : unit -> unit = fun () -> raise Exit [@@inline never]
+++ /dev/null
-Fatal error: exception Stdlib.Exit
-Raised at file "pr6920_why_swallow.ml", line 13, characters 35-45
-Called from file "pr6920_why_swallow.ml", line 16, characters 4-13
-Called from file "pr6920_why_swallow.ml", line 23, characters 2-6
--- /dev/null
+Fatal error: exception Stdlib.Exit
+Raised at Pr6920_why_swallow.why in file "pr6920_why_swallow.ml", line 9, characters 35-45
+Called from Pr6920_why_swallow.f in file "pr6920_why_swallow.ml", line 12, characters 4-13
+Called from Pr6920_why_swallow in file "pr6920_why_swallow.ml", line 19, characters 2-6
+++ /dev/null
-a
-No exception
-b
-Uncaught exception Raw_backtrace.Error("b")
-Raised at file "raw_backtrace.ml", line 16, characters 21-32
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 25, characters 4-11
-Re-raised at file "raw_backtrace.ml", line 27, characters 68-71
-Called from file "raw_backtrace.ml", line 42, characters 11-23
-Uncaught exception Raw_backtrace.Error("c")
-Raised at file "raw_backtrace.ml", line 28, characters 26-37
-Called from file "raw_backtrace.ml", line 42, characters 11-23
-Uncaught exception Raw_backtrace.Error("d")
-Raised at file "raw_backtrace.ml", line 16, characters 21-32
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 25, characters 4-11
-Called from file "raw_backtrace.ml", line 42, characters 11-23
-e
-Uncaught exception Raw_backtrace.Error("e")
-Raised at file "raw_backtrace.ml", line 16, characters 21-32
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 25, characters 4-11
-Re-raised at file "raw_backtrace.ml", line 34, characters 39-42
-Called from file "raw_backtrace.ml", line 42, characters 11-23
-f
-Uncaught exception Raw_backtrace.Localized(_)
-Raised at file "raw_backtrace.ml", line 16, characters 21-32
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 25, characters 4-11
-Re-raised at file "raw_backtrace.ml", line 38, characters 39-54
-Called from file "raw_backtrace.ml", line 42, characters 11-23
-Uncaught exception Invalid_argument("index out of bounds")
-Raised by primitive operation at file "raw_backtrace.ml", line 42, characters 14-22
(* TEST
flags = "-g"
ocamlrunparam += ",b=1"
- * bytecode
- reference = "${test_source_directory}/raw_backtrace.byte.reference"
- * native
- reference = "${test_source_directory}/raw_backtrace.opt.reference"
- compare_programs = "false"
+ compare_programs = "false"
*)
(* A test for stack backtraces *)
+++ /dev/null
-a
-No exception
-b
-Uncaught exception Raw_backtrace.Error("b")
-Raised at file "raw_backtrace.ml", line 16, characters 16-32
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 25, characters 4-11
-Re-raised at file "raw_backtrace.ml", line 27, characters 62-71
-Called from file "raw_backtrace.ml", line 42, characters 11-23
-Uncaught exception Raw_backtrace.Error("c")
-Raised at file "raw_backtrace.ml", line 28, characters 20-37
-Called from file "raw_backtrace.ml", line 42, characters 11-23
-Uncaught exception Raw_backtrace.Error("d")
-Raised at file "raw_backtrace.ml", line 16, characters 16-32
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 25, characters 4-11
-Called from file "raw_backtrace.ml", line 42, characters 11-23
-e
-Uncaught exception Raw_backtrace.Error("e")
-Raised at file "raw_backtrace.ml", line 16, characters 16-32
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 25, characters 4-11
-Re-raised at file "raw_backtrace.ml", line 34, characters 9-45
-Called from file "raw_backtrace.ml", line 42, characters 11-23
-f
-Uncaught exception Raw_backtrace.Localized(_)
-Raised at file "raw_backtrace.ml", line 16, characters 16-32
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 16, characters 42-53
-Called from file "raw_backtrace.ml", line 25, characters 4-11
-Re-raised at file "raw_backtrace.ml", line 38, characters 9-57
-Called from file "raw_backtrace.ml", line 42, characters 11-23
-Uncaught exception Invalid_argument("index out of bounds")
-Raised by primitive operation at file "raw_backtrace.ml", line 42, characters 14-22
--- /dev/null
+a
+No exception
+b
+Uncaught exception Raw_backtrace.Error("b")
+Raised at Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 16-32
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.g in file "raw_backtrace.ml", line 21, characters 4-11
+Re-raised at Raw_backtrace.g in file "raw_backtrace.ml", line 23, characters 62-71
+Called from Raw_backtrace.backtrace in file "raw_backtrace.ml", line 38, characters 11-23
+Uncaught exception Raw_backtrace.Error("c")
+Raised at Raw_backtrace.g in file "raw_backtrace.ml", line 24, characters 20-37
+Called from Raw_backtrace.backtrace in file "raw_backtrace.ml", line 38, characters 11-23
+Uncaught exception Raw_backtrace.Error("d")
+Raised at Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 16-32
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.g in file "raw_backtrace.ml", line 21, characters 4-11
+Called from Raw_backtrace.backtrace in file "raw_backtrace.ml", line 38, characters 11-23
+e
+Uncaught exception Raw_backtrace.Error("e")
+Raised at Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 16-32
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.g in file "raw_backtrace.ml", line 21, characters 4-11
+Re-raised at Raw_backtrace.g in file "raw_backtrace.ml", line 30, characters 9-45
+Called from Raw_backtrace.backtrace in file "raw_backtrace.ml", line 38, characters 11-23
+f
+Uncaught exception Raw_backtrace.Localized(_)
+Raised at Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 16-32
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.f in file "raw_backtrace.ml", line 12, characters 42-53
+Called from Raw_backtrace.g in file "raw_backtrace.ml", line 21, characters 4-11
+Re-raised at Raw_backtrace.g in file "raw_backtrace.ml", line 34, characters 9-57
+Called from Raw_backtrace.backtrace in file "raw_backtrace.ml", line 38, characters 11-23
+Uncaught exception Invalid_argument("index out of bounds")
+Raised by primitive operation at Raw_backtrace.backtrace in file "raw_backtrace.ml", line 38, characters 14-22
module type S
let f (module _ : S) = ()
+
+type re = { mutable cell : string; }
+
+let s = { cell = "" }
+
+module _ = struct
+ let () = s.cell <- "Hello World!"
+end
+
+let drop _ = ()
+
+let () = drop s.cell
[0: [0]]))
(seq (ignore (let (x = [0: 4 2]) (makeblock 0 x)))
(apply (field 1 (global CamlinternalMod!)) [0: [0]] A
- (module-defn(A) anonymous.ml(23):567-608 A))
+ (module-defn(A) Anonymous anonymous.ml(23):567-608 A))
(apply (field 1 (global CamlinternalMod!)) [0: [0]] B
- (module-defn(B) anonymous.ml(33):703-773
+ (module-defn(B) Anonymous anonymous.ml(33):703-773
(let (x = [0: "foo" "bar"]) (makeblock 0))))
- (let (f = (function param 0a)) (makeblock 0 A B f))))))
+ (let (f = (function param 0a) s = (makemutable 0 ""))
+ (seq
+ (ignore
+ (let (*match* = (setfield_ptr 0 s "Hello World!"))
+ (makeblock 0)))
+ (let
+ (drop = (function param 0a) *match* = (apply drop (field 0 s)))
+ (makeblock 0 A B f s drop))))))))
[0: [0]]))
(seq (ignore (let (x = [0: 4 2]) (makeblock 0 x)))
(apply (field 1 (global CamlinternalMod!)) [0: [0]] A
- (module-defn(A) anonymous.ml(23):567-608 A))
+ (module-defn(A) Anonymous anonymous.ml(23):567-608 A))
(apply (field 1 (global CamlinternalMod!)) [0: [0]] B
- (module-defn(B) anonymous.ml(33):703-773
+ (module-defn(B) Anonymous anonymous.ml(33):703-773
(let (x = [0: "foo" "bar"]) (makeblock 0))))
- (let (f = (function param 0a)) (makeblock 0 A B f)))))
+ (let (f = (function param 0a) s = (makemutable 0 ""))
+ (seq
+ (ignore
+ (let (*match* = (setfield_ptr 0 s "Hello World!")) (makeblock 0)))
+ (let
+ (drop = (function param 0a) *match* = (apply drop (field 0 s)))
+ (makeblock 0 A B f s drop)))))))
(setfield_ptr(root-init) 1 (global Anonymous!) B)
(let (f = (function param 0a))
(setfield_ptr(root-init) 2 (global Anonymous!) f))
+ (let (s = (makemutable 0 ""))
+ (setfield_ptr(root-init) 3 (global Anonymous!) s))
+ (ignore
+ (let
+ (*match* =
+ (setfield_ptr 0 (field 3 (global Anonymous!)) "Hello World!"))
+ (makeblock 0)))
+ (let (drop = (function param 0a))
+ (setfield_ptr(root-init) 4 (global Anonymous!) drop))
+ (let
+ (*match* =
+ (apply (field 4 (global Anonymous!))
+ (field 0 (field 3 (global Anonymous!)))))
+ 0a)
0a)))
--- /dev/null
+(* TEST *)
+
+let f () n () =
+ n
+
+let g () =
+ let r = ref 0 in
+ f (incr r) !r (incr r)
+
+let () = print_int (g ())
--- /dev/null
+1
\ No newline at end of file
--- /dev/null
+(* TEST *)
+
+let[@inline never] small_match n x =
+ let (left, right) = match x with
+ | 0 -> n, 42
+ | 1 -> 42, n
+ | _ -> assert false in
+ left - right
+
+let[@inline never] big_match n x =
+ let (left, right) = match x with
+ | 0 -> n, 42
+ | 1 -> 42, n
+ | 2 -> 42-n, 0
+ | 3 -> 0, 42-n
+ | 4 -> n/2, n/2
+ | 5 -> n, n
+ | _ -> assert false in
+ left - right
+
+let[@inline never] string_match n x =
+ let (left, right) = match x with
+ | "0" -> n, 42
+ | "1" -> 42, n
+ | "2" -> 42-n, 0
+ | "3" -> 0, 42-n
+ | "4" -> n/2, n/2
+ | "5" -> n, n
+ | _ -> assert false in
+ left - right
+
+
+
+
+let printf = Printf.printf
+
+let test f n i =
+ let mw_overhead =
+ let a = Gc.minor_words () in
+ let b = Gc.minor_words () in
+ b -. a in
+ let mw = Gc.minor_words () in
+ let k = f n i in
+ assert (k = 0);
+ let mw' = Gc.minor_words () in
+ let delta = int_of_float (mw' -. mw -. mw_overhead) in
+ printf "allocated %d words\n" delta
+
+let () =
+ let n = 42 in
+ printf "small_match:\n";
+ for i = 0 to 1 do test small_match n i done;
+ printf "big_match:\n";
+ for i = 0 to 5 do test big_match n i done;
+ printf "string_match:\n";
+ for i = 0 to 5 do test string_match n (string_of_int i) done
--- /dev/null
+small_match:
+allocated 0 words
+allocated 0 words
+big_match:
+allocated 0 words
+allocated 0 words
+allocated 0 words
+allocated 0 words
+allocated 0 words
+allocated 0 words
+string_match:
+allocated 0 words
+allocated 0 words
+allocated 0 words
+allocated 0 words
+allocated 0 words
+allocated 0 words
+#include <stdio.h>
+
#include <caml/minor_gc.h>
#include <caml/memory.h>
#include <caml/mlvalues.h>
include ocamlcommon
* expect
*)
+[@@@alert "-deprecated"]
module L = Longident
+
[%%expect {|
module L = Longident
|}]
val last_dot_apply : string = "foo"
|}];;
+type parse_result = { flat: L.t; spec:L.t; any_is_correct:bool }
+let test specialized s =
+ let spec = specialized (Lexing.from_string s) in
+ { flat = L.parse s;
+ spec;
+ any_is_correct = Parse.longident (Lexing.from_string s) = spec;
+ }
+
let parse_empty = L.parse ""
+let parse_empty_val = Parse.longident (Lexing.from_string "")
[%%expect {|
+type parse_result = { flat : L.t; spec : L.t; any_is_correct : bool; }
+val test : (Lexing.lexbuf -> L.t) -> string -> parse_result = <fun>
val parse_empty : L.t = L.Lident ""
+Exception:
+Syntaxerr.Error
+ (Syntaxerr.Other
+ {Location.loc_start =
+ {Lexing.pos_fname = ""; pos_lnum = 1; pos_bol = 0; pos_cnum = 0};
+ loc_end =
+ {Lexing.pos_fname = ""; pos_lnum = 1; pos_bol = 0; pos_cnum = 0};
+ loc_ghost = false}).
|}]
-let parse_ident = L.parse "foo"
+let parse_ident = test Parse.val_ident "foo"
[%%expect {|
-val parse_ident : L.t = L.Lident "foo"
+val parse_ident : parse_result =
+ {flat = L.Lident "foo"; spec = L.Lident "foo"; any_is_correct = true}
|}]
-let parse_dot = L.parse "M.foo"
+let parse_dot = test Parse.val_ident "M.foo"
[%%expect {|
-val parse_dot : L.t = L.Ldot (L.Lident "M", "foo")
+val parse_dot : parse_result =
+ {flat = L.Ldot (L.Lident "M", "foo"); spec = L.Ldot (L.Lident "M", "foo");
+ any_is_correct = true}
|}]
-let parse_path = L.parse "M.N.foo"
+let parse_path = test Parse.val_ident "M.N.foo"
[%%expect {|
-val parse_path : L.t = L.Ldot (L.Ldot (L.Lident "M", "N"), "foo")
+val parse_path : parse_result =
+ {flat = L.Ldot (L.Ldot (L.Lident "M", "N"), "foo");
+ spec = L.Ldot (L.Ldot (L.Lident "M", "N"), "foo"); any_is_correct = true}
|}]
-let parse_complex = L.parse "M.F(M.N).N.foo"
+let parse_complex = test Parse.type_ident "M.F(M.N).N.foo"
(* the result below is a known misbehavior of Longident.parse
- which does not handle applications properly. Fixing it
- would be nice, but we soo no convenient way to do it without
- introducing unpleasant dependencies. *)
+ which does not handle applications properly. *)
+[%%expect {|
+val parse_complex : parse_result =
+ {flat =
+ L.Ldot (L.Ldot (L.Ldot (L.Ldot (L.Lident "M", "F(M"), "N)"), "N"), "foo");
+ spec =
+ L.Ldot
+ (L.Ldot
+ (L.Lapply (L.Ldot (L.Lident "M", "F"), L.Ldot (L.Lident "M", "N")),
+ "N"),
+ "foo");
+ any_is_correct = true}
+|}]
+
+let parse_op = test Parse.val_ident "M.(.%.()<-)"
+(* the result below is another known misbehavior of Longident.parse. *)
+[%%expect {|
+val parse_op : parse_result =
+ {flat = L.Ldot (L.Ldot (L.Ldot (L.Lident "M", "("), "%"), "()<-)");
+ spec = L.Ldot (L.Lident "M", ".%.()<-"); any_is_correct = true}
+|}]
+
+
+let parse_let_op = test Parse.val_ident "M.(let+*!)"
[%%expect {|
-val parse_complex : L.t =
- L.Ldot (L.Ldot (L.Ldot (L.Ldot (L.Lident "M", "F(M"), "N)"), "N"), "foo")
+val parse_let_op : parse_result =
+ {flat = L.Ldot (L.Lident "M", "(let+*!)");
+ spec = L.Ldot (L.Lident "M", "let+*!"); any_is_correct = true}
+|}]
+
+let constr = test Parse.constr_ident "true"
+[%%expect{|
+val constr : parse_result =
+ {flat = L.Lident "true"; spec = L.Lident "true"; any_is_correct = true}
+|}]
+
+let prefix_constr = test Parse.constr_ident "A.B.C.(::)"
+[%%expect{|
+val prefix_constr : parse_result =
+ {flat = L.Ldot (L.Ldot (L.Ldot (L.Lident "A", "B"), "C"), "(::)");
+ spec = L.Ldot (L.Ldot (L.Ldot (L.Lident "A", "B"), "C"), "::");
+ any_is_correct = true}
+|}]
+
+
+
+let mod_ext = test Parse.extended_module_path "A.F(B.C(X)).G(Y).D"
+[%%expect{|
+val mod_ext : parse_result =
+ {flat =
+ L.Ldot (L.Ldot (L.Ldot (L.Ldot (L.Lident "A", "F(B"), "C(X))"), "G(Y)"),
+ "D");
+ spec =
+ L.Ldot
+ (L.Lapply
+ (L.Ldot
+ (L.Lapply (L.Ldot (L.Lident "A", "F"),
+ L.Lapply (L.Ldot (L.Lident "B", "C"), L.Lident "X")),
+ "G"),
+ L.Lident "Y"),
+ "D");
+ any_is_correct = true}
|}]
+
let string_of_longident lid = Format.asprintf "%a" Pprintast.longident lid
[%%expect{|
val string_of_longident : Longident.t -> string = <fun>
[%%expect {|
val str_empty : string = ""
|}]
-let str_ident = string_of_longident parse_ident
+let str_ident = string_of_longident parse_ident.flat
[%%expect {|
val str_ident : string = "foo"
|}]
-let str_dot = string_of_longident parse_dot
+let str_dot = string_of_longident parse_dot.flat
[%%expect {|
val str_dot : string = "M.foo"
|}]
-let str_path = string_of_longident parse_path
+let str_path = string_of_longident parse_path.flat
[%%expect {|
val str_path : string = "M.N.foo"
|}]
--- /dev/null
+[
+ structure_item (test_locations.ml[42,1260+0]..[44,1298+34])
+ Pstr_value Rec
+ [
+ <def>
+ pattern (test_locations.ml[42,1260+8]..[42,1260+11])
+ Ppat_var "fib" (test_locations.ml[42,1260+8]..[42,1260+11])
+ expression (test_locations.ml[42,1260+14]..[44,1298+34])
+ Pexp_function
+ [
+ <case>
+ pattern (test_locations.ml[43,1283+4]..[43,1283+9])
+ Ppat_or
+ pattern (test_locations.ml[43,1283+4]..[43,1283+5])
+ Ppat_constant PConst_int (0,None)
+ pattern (test_locations.ml[43,1283+8]..[43,1283+9])
+ Ppat_constant PConst_int (1,None)
+ expression (test_locations.ml[43,1283+13]..[43,1283+14])
+ Pexp_constant PConst_int (1,None)
+ <case>
+ pattern (test_locations.ml[44,1298+4]..[44,1298+5])
+ Ppat_var "n" (test_locations.ml[44,1298+4]..[44,1298+5])
+ expression (test_locations.ml[44,1298+9]..[44,1298+34])
+ Pexp_apply
+ expression (test_locations.ml[44,1298+21]..[44,1298+22])
+ Pexp_ident "+" (test_locations.ml[44,1298+21]..[44,1298+22])
+ [
+ <arg>
+ Nolabel
+ expression (test_locations.ml[44,1298+9]..[44,1298+20])
+ Pexp_apply
+ expression (test_locations.ml[44,1298+9]..[44,1298+12])
+ Pexp_ident "fib" (test_locations.ml[44,1298+9]..[44,1298+12])
+ [
+ <arg>
+ Nolabel
+ expression (test_locations.ml[44,1298+13]..[44,1298+20])
+ Pexp_apply
+ expression (test_locations.ml[44,1298+16]..[44,1298+17])
+ Pexp_ident "-" (test_locations.ml[44,1298+16]..[44,1298+17])
+ [
+ <arg>
+ Nolabel
+ expression (test_locations.ml[44,1298+14]..[44,1298+15])
+ Pexp_ident "n" (test_locations.ml[44,1298+14]..[44,1298+15])
+ <arg>
+ Nolabel
+ expression (test_locations.ml[44,1298+18]..[44,1298+19])
+ Pexp_constant PConst_int (1,None)
+ ]
+ ]
+ <arg>
+ Nolabel
+ expression (test_locations.ml[44,1298+23]..[44,1298+34])
+ Pexp_apply
+ expression (test_locations.ml[44,1298+23]..[44,1298+26])
+ Pexp_ident "fib" (test_locations.ml[44,1298+23]..[44,1298+26])
+ [
+ <arg>
+ Nolabel
+ expression (test_locations.ml[44,1298+27]..[44,1298+34])
+ Pexp_apply
+ expression (test_locations.ml[44,1298+30]..[44,1298+31])
+ Pexp_ident "-" (test_locations.ml[44,1298+30]..[44,1298+31])
+ [
+ <arg>
+ Nolabel
+ expression (test_locations.ml[44,1298+28]..[44,1298+29])
+ Pexp_ident "n" (test_locations.ml[44,1298+28]..[44,1298+29])
+ <arg>
+ Nolabel
+ expression (test_locations.ml[44,1298+32]..[44,1298+33])
+ Pexp_constant PConst_int (2,None)
+ ]
+ ]
+ ]
+ ]
+ ]
+]
+
+let rec fib = function | 0|1 -> 1 | n -> (fib (n - 1)) + (fib (n - 2))
+[
+ structure_item (test_locations.ml[42,1260+0]..test_locations.ml[44,1298+34])
+ Tstr_value Rec
+ [
+ <def>
+ pattern (test_locations.ml[42,1260+8]..test_locations.ml[42,1260+11])
+ Tpat_var "fib/80"
+ expression (test_locations.ml[42,1260+14]..test_locations.ml[44,1298+34])
+ Texp_function
+ Nolabel
+ [
+ <case>
+ pattern (test_locations.ml[43,1283+4]..test_locations.ml[43,1283+9])
+ Tpat_or
+ pattern (test_locations.ml[43,1283+4]..test_locations.ml[43,1283+5])
+ Tpat_constant Const_int 0
+ pattern (test_locations.ml[43,1283+8]..test_locations.ml[43,1283+9])
+ Tpat_constant Const_int 1
+ expression (test_locations.ml[43,1283+13]..test_locations.ml[43,1283+14])
+ Texp_constant Const_int 1
+ <case>
+ pattern (test_locations.ml[44,1298+4]..test_locations.ml[44,1298+5])
+ Tpat_var "n/81"
+ expression (test_locations.ml[44,1298+9]..test_locations.ml[44,1298+34])
+ Texp_apply
+ expression (test_locations.ml[44,1298+21]..test_locations.ml[44,1298+22])
+ Texp_ident "Stdlib!.+"
+ [
+ <arg>
+ Nolabel
+ expression (test_locations.ml[44,1298+9]..test_locations.ml[44,1298+20])
+ Texp_apply
+ expression (test_locations.ml[44,1298+9]..test_locations.ml[44,1298+12])
+ Texp_ident "fib/80"
+ [
+ <arg>
+ Nolabel
+ expression (test_locations.ml[44,1298+13]..test_locations.ml[44,1298+20])
+ Texp_apply
+ expression (test_locations.ml[44,1298+16]..test_locations.ml[44,1298+17])
+ Texp_ident "Stdlib!.-"
+ [
+ <arg>
+ Nolabel
+ expression (test_locations.ml[44,1298+14]..test_locations.ml[44,1298+15])
+ Texp_ident "n/81"
+ <arg>
+ Nolabel
+ expression (test_locations.ml[44,1298+18]..test_locations.ml[44,1298+19])
+ Texp_constant Const_int 1
+ ]
+ ]
+ <arg>
+ Nolabel
+ expression (test_locations.ml[44,1298+23]..test_locations.ml[44,1298+34])
+ Texp_apply
+ expression (test_locations.ml[44,1298+23]..test_locations.ml[44,1298+26])
+ Texp_ident "fib/80"
+ [
+ <arg>
+ Nolabel
+ expression (test_locations.ml[44,1298+27]..test_locations.ml[44,1298+34])
+ Texp_apply
+ expression (test_locations.ml[44,1298+30]..test_locations.ml[44,1298+31])
+ Texp_ident "Stdlib!.-"
+ [
+ <arg>
+ Nolabel
+ expression (test_locations.ml[44,1298+28]..test_locations.ml[44,1298+29])
+ Texp_ident "n/81"
+ <arg>
+ Nolabel
+ expression (test_locations.ml[44,1298+32]..test_locations.ml[44,1298+33])
+ Texp_constant Const_int 2
+ ]
+ ]
+ ]
+ ]
+ ]
+]
+
+(setglobal Test_locations!
+ (letrec
+ (fib/80
+ (function n/81[int] : int
+ (funct-body Test_locations.fib test_locations.ml(42):1274-1332
+ (if (isout 1 n/81)
+ (before Test_locations.fib test_locations.ml(44):1307-1332
+ (+
+ (after Test_locations.fib test_locations.ml(44):1307-1318
+ (apply fib/80 (- n/81 1)))
+ (after Test_locations.fib test_locations.ml(44):1321-1332
+ (apply fib/80 (- n/81 2)))))
+ (before Test_locations.fib test_locations.ml(43):1296-1297 1)))))
+ (pseudo <unknown location> (makeblock 0 fib/80))))
--- /dev/null
+
+cmm:
+(data)
+(data
+ int 3063
+ "camlTest_locations__1":
+ addr "camlTest_locations__fib_80"
+ int 3)
+(data int 1792 global "camlTest_locations" "camlTest_locations": int 1)
+(data
+ global "camlTest_locations__gc_roots"
+ "camlTest_locations__gc_roots":
+ addr "camlTest_locations"
+ int 0)
+(function{test_locations.ml:42,14-72} camlTest_locations__fib_80 (n/81: val)
+ (if (<a 3 n/81)
+ (+
+ (+
+ (app{test_locations.ml:44,9-20} "camlTest_locations__fib_80"
+ (+ n/81 -2) val)
+ (app{test_locations.ml:44,23-34} "camlTest_locations__fib_80"
+ (+ n/81 -4) val))
+ -1)
+ 3))
+
+(function camlTest_locations__entry ()
+ (let clos/84 "camlTest_locations__1"
+ (store val(root-init) "camlTest_locations" clos/84))
+ 1a)
+
+(data)
--- /dev/null
+
+cmm:
+(data)
+(data
+ int 3063
+ global "camlTest_locations__set_of_closures_29"
+ "camlTest_locations__set_of_closures_29":
+ global "camlTest_locations__fib_5_closure"
+ "camlTest_locations__fib_5_closure":
+ addr "camlTest_locations__fib_5"
+ int 3)
+(data
+ global "camlTest_locations__gc_roots"
+ "camlTest_locations__gc_roots":
+ int 0)
+(function{test_locations.ml:42,14-72} camlTest_locations__fib_5 (n/84: val)
+ (if (<a 3 n/84)
+ (let
+ Paddint_arg/91
+ (app{test_locations.ml:44,23-34} "camlTest_locations__fib_5"
+ (+ n/84 -4) val)
+ (+
+ (+
+ (app{test_locations.ml:44,9-20} "camlTest_locations__fib_5"
+ (+ n/84 -2) val)
+ Paddint_arg/91)
+ -1))
+ 3))
+
+(data
+ int 1792
+ global "camlTest_locations"
+ "camlTest_locations":
+ addr "camlTest_locations__fib_5_closure")
+(data)
+(function camlTest_locations__entry () 1a)
+
+(data)
--- /dev/null
+[
+ structure_item
+ Pstr_value Rec
+ [
+ <def>
+ pattern
+ Ppat_var "fib"
+ expression
+ Pexp_function
+ [
+ <case>
+ pattern
+ Ppat_or
+ pattern
+ Ppat_constant PConst_int (0,None)
+ pattern
+ Ppat_constant PConst_int (1,None)
+ expression
+ Pexp_constant PConst_int (1,None)
+ <case>
+ pattern
+ Ppat_var "n"
+ expression
+ Pexp_apply
+ expression
+ Pexp_ident "+"
+ [
+ <arg>
+ Nolabel
+ expression
+ Pexp_apply
+ expression
+ Pexp_ident "fib"
+ [
+ <arg>
+ Nolabel
+ expression
+ Pexp_apply
+ expression
+ Pexp_ident "-"
+ [
+ <arg>
+ Nolabel
+ expression
+ Pexp_ident "n"
+ <arg>
+ Nolabel
+ expression
+ Pexp_constant PConst_int (1,None)
+ ]
+ ]
+ <arg>
+ Nolabel
+ expression
+ Pexp_apply
+ expression
+ Pexp_ident "fib"
+ [
+ <arg>
+ Nolabel
+ expression
+ Pexp_apply
+ expression
+ Pexp_ident "-"
+ [
+ <arg>
+ Nolabel
+ expression
+ Pexp_ident "n"
+ <arg>
+ Nolabel
+ expression
+ Pexp_constant PConst_int (2,None)
+ ]
+ ]
+ ]
+ ]
+ ]
+]
+
+let rec fib = function | 0|1 -> 1 | n -> (fib (n - 1)) + (fib (n - 2))
+[
+ structure_item
+ Tstr_value Rec
+ [
+ <def>
+ pattern
+ Tpat_var "fib/80"
+ expression
+ Texp_function
+ Nolabel
+ [
+ <case>
+ pattern
+ Tpat_or
+ pattern
+ Tpat_constant Const_int 0
+ pattern
+ Tpat_constant Const_int 1
+ expression
+ Texp_constant Const_int 1
+ <case>
+ pattern
+ Tpat_var "n/81"
+ expression
+ Texp_apply
+ expression
+ Texp_ident "Stdlib!.+"
+ [
+ <arg>
+ Nolabel
+ expression
+ Texp_apply
+ expression
+ Texp_ident "fib/80"
+ [
+ <arg>
+ Nolabel
+ expression
+ Texp_apply
+ expression
+ Texp_ident "Stdlib!.-"
+ [
+ <arg>
+ Nolabel
+ expression
+ Texp_ident "n/81"
+ <arg>
+ Nolabel
+ expression
+ Texp_constant Const_int 1
+ ]
+ ]
+ <arg>
+ Nolabel
+ expression
+ Texp_apply
+ expression
+ Texp_ident "fib/80"
+ [
+ <arg>
+ Nolabel
+ expression
+ Texp_apply
+ expression
+ Texp_ident "Stdlib!.-"
+ [
+ <arg>
+ Nolabel
+ expression
+ Texp_ident "n/81"
+ <arg>
+ Nolabel
+ expression
+ Texp_constant Const_int 2
+ ]
+ ]
+ ]
+ ]
+ ]
+]
+
+(setglobal Test_locations!
+ (letrec
+ (fib/80
+ (function n/81[int] : int
+ (if (isout 1 n/81)
+ (+ (apply fib/80 (- n/81 1)) (apply fib/80 (- n/81 2))) 1)))
+ (makeblock 0 fib/80)))
--- /dev/null
+
+cmm:
+(data)
+(data
+ int 3063
+ "camlTest_locations__1":
+ addr "camlTest_locations__fib_80"
+ int 3)
+(data int 1792 global "camlTest_locations" "camlTest_locations": int 1)
+(data
+ global "camlTest_locations__gc_roots"
+ "camlTest_locations__gc_roots":
+ addr "camlTest_locations"
+ int 0)
+(function camlTest_locations__fib_80 (n/81: val)
+ (if (<a 3 n/81)
+ (+
+ (+ (app "camlTest_locations__fib_80" (+ n/81 -2) val)
+ (app "camlTest_locations__fib_80" (+ n/81 -4) val))
+ -1)
+ 3))
+
+(function camlTest_locations__entry ()
+ (let clos/84 "camlTest_locations__1"
+ (store val(root-init) "camlTest_locations" clos/84))
+ 1a)
+
+(data)
--- /dev/null
+
+cmm:
+(data)
+(data
+ int 3063
+ global "camlTest_locations__set_of_closures_29"
+ "camlTest_locations__set_of_closures_29":
+ global "camlTest_locations__fib_5_closure"
+ "camlTest_locations__fib_5_closure":
+ addr "camlTest_locations__fib_5"
+ int 3)
+(data
+ global "camlTest_locations__gc_roots"
+ "camlTest_locations__gc_roots":
+ int 0)
+(function camlTest_locations__fib_5 (n/84: val)
+ (if (<a 3 n/84)
+ (let Paddint_arg/91 (app "camlTest_locations__fib_5" (+ n/84 -4) val)
+ (+ (+ (app "camlTest_locations__fib_5" (+ n/84 -2) val) Paddint_arg/91)
+ -1))
+ 3))
+
+(data
+ int 1792
+ global "camlTest_locations"
+ "camlTest_locations":
+ addr "camlTest_locations__fib_5_closure")
+(data)
+(function camlTest_locations__entry () 1a)
+
+(data)
--- /dev/null
+(* TEST
+compile_only="true"
+
+* setup-ocamlc.byte-build-env
+** ocamlc.byte
+flags="-g -dno-locations -dsource -dparsetree -dtypedtree -dlambda"
+*** check-ocamlc.byte-output
+compiler_reference =
+ "${test_source_directory}/test_locations.dno-locations.ocamlc.reference"
+
+* setup-ocamlopt.byte-build-env
+** ocamlopt.byte
+flags="-g -dno-locations -dcmm"
+*** no-flambda
+**** check-ocamlopt.byte-output
+compiler_reference =
+ "${test_source_directory}/test_locations.dno-locations.ocamlopt.clambda.reference"
+*** flambda
+**** check-ocamlc.byte-output
+compiler_reference =
+ "${test_source_directory}/test_locations.dno-locations.ocamlopt.flambda.reference"
+
+* setup-ocamlc.byte-build-env
+** ocamlc.byte
+flags="-g -dlocations -dsource -dparsetree -dtypedtree -dlambda"
+*** check-ocamlc.byte-output
+compiler_reference =
+ "${test_source_directory}/test_locations.dlocations.ocamlc.reference"
+
+* setup-ocamlopt.byte-build-env
+** ocamlopt.byte
+flags="-g -dlocations -dcmm"
+*** no-flambda
+**** check-ocamlopt.byte-output
+compiler_reference =
+ "${test_source_directory}/test_locations.dlocations.ocamlopt.clambda.reference"
+*** flambda
+**** check-ocamlc.byte-output
+compiler_reference =
+ "${test_source_directory}/test_locations.dlocations.ocamlopt.flambda.reference"
+*)
+let rec fib = function
+ | 0 | 1 -> 1
+ | n -> fib (n - 1) + fib (n - 2)
+;;
(setglobal Functors!
(let
(O =
- (module-defn(O) functors.ml(12):184-279
+ (module-defn(O) Functors functors.ml(12):184-279
(function X is_a_functor always_inline
(let
(cow = (function x[int] : int (apply (field 0 X) x))
sheep = (function x[int] : int (+ 1 (apply cow x))))
(makeblock 0 cow sheep))))
F =
- (module-defn(F) functors.ml(17):281-392
+ (module-defn(F) Functors functors.ml(17):281-392
(function X Y is_a_functor always_inline
(let
(cow =
sheep = (function x[int] : int (+ 1 (apply cow x))))
(makeblock 0 cow sheep))))
F1 =
- (module-defn(F1) functors.ml(31):516-632
+ (module-defn(F1) Functors functors.ml(31):516-632
(function X Y is_a_functor always_inline
(let
(sheep =
(+ 1 (apply (field 0 Y) (apply (field 0 X) x)))))
(makeblock 0 sheep))))
F2 =
- (module-defn(F2) functors.ml(36):634-784
+ (module-defn(F2) Functors functors.ml(36):634-784
(function X Y is_a_functor always_inline
(let
(X =a (makeblock 0 (field 1 X))
(+ 1 (apply (field 0 Y) (apply (field 0 X) x)))))
(makeblock 0 sheep))))
M =
- (module-defn(M) functors.ml(41):786-970
+ (module-defn(M) Functors functors.ml(41):786-970
(let
(F =
- (module-defn(F) functors.ml(44):849-966
+ (module-defn(F) Functors.M functors.ml(44):849-966
(function X Y is_a_functor always_inline
(let
(cow =
open Set.Make(String);;
[%%expect{|
+type elt = String.t
+type t = Set.Make(String).t
+val empty : t = <abstr>
+val is_empty : t -> bool = <fun>
+val mem : elt -> t -> bool = <fun>
+val add : elt -> t -> t = <fun>
+val singleton : elt -> t = <fun>
+val remove : elt -> t -> t = <fun>
+val union : t -> t -> t = <fun>
+val inter : t -> t -> t = <fun>
+val disjoint : t -> t -> bool = <fun>
+val diff : t -> t -> t = <fun>
+val compare : t -> t -> int = <fun>
+val equal : t -> t -> bool = <fun>
+val subset : t -> t -> bool = <fun>
+val iter : (elt -> unit) -> t -> unit = <fun>
+val map : (elt -> elt) -> t -> t = <fun>
+val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a = <fun>
+val for_all : (elt -> bool) -> t -> bool = <fun>
+val exists : (elt -> bool) -> t -> bool = <fun>
+val filter : (elt -> bool) -> t -> t = <fun>
+val filter_map : (elt -> elt option) -> t -> t = <fun>
+val partition : (elt -> bool) -> t -> t * t = <fun>
+val cardinal : t -> int = <fun>
+val elements : t -> elt list = <fun>
+val min_elt : t -> elt = <fun>
+val min_elt_opt : t -> elt option = <fun>
+val max_elt : t -> elt = <fun>
+val max_elt_opt : t -> elt option = <fun>
+val choose : t -> elt = <fun>
+val choose_opt : t -> elt option = <fun>
+val split : elt -> t -> t * bool * t = <fun>
+val find : elt -> t -> elt = <fun>
+val find_opt : elt -> t -> elt option = <fun>
+val find_first : (elt -> bool) -> t -> elt = <fun>
+val find_first_opt : (elt -> bool) -> t -> elt option = <fun>
+val find_last : (elt -> bool) -> t -> elt = <fun>
+val find_last_opt : (elt -> bool) -> t -> elt option = <fun>
+val of_list : elt list -> t = <fun>
+val to_seq_from : elt -> t -> elt Seq.t = <fun>
+val to_seq : t -> elt Seq.t = <fun>
+val add_seq : elt Seq.t -> t -> t = <fun>
+val of_seq : elt Seq.t -> t = <fun>
|}]
let e = empty;;
let x = singleton "hidden"
end;;
[%%expect{|
+val x : t = <abstr>
|}];;
elements (union x (of_list ["a"; "b"]));;
open (List : sig val map : ('a -> 'b) -> 'a list -> 'b list end);;
[%%expect{|
+val map : ('a -> 'b) -> 'a list -> 'b list = <fun>
|}]
let l = map succ [0;1;2;3]
let current () = !counter
end
[%%expect{|
+val inc : unit -> unit = <fun>
+val dec : unit -> unit = <fun>
+val current : unit -> int = <fun>
|}]
let () =
--- /dev/null
+(* TEST
+ * hasinstrumentedruntime
+ ** native
+ flags = "-runtime-variant=i"
+*)
+
+(* Test if the instrumented runtime is in working condition *)
+
+let _ =
+ Gc.eventlog_pause ();
+ Gc.eventlog_resume()
--- /dev/null
+#!/bin/sh
+
+export OCAML_EVENTLOG_ENABLED=1
+export OCAML_EVENTLOG_PREFIX=${program}
+
+if [ "${os_type}" = "Win32" ] ; then
+ program=$(cygpath "$program")
+fi
+
+rm -f "${program}"*.eventlog*
+${program} > ${output} &
+
+pid=$!
+wait $pid
+
+ls "${program}".*.eventlog | grep '\.[0-9][0-9]*\.eventlog$' | \
+while IFS= read -r file; do
+ touch ${program}.eventlogs
+ if [ ! -e "${program}.eventlog" ] ; then
+ touch ${program}.eventlog
+ else
+ rm -f ${program}.eventlog
+ break
+ fi
+done
+
+if [ -f "${program}.eventlog" ]; then
+ exit ${TEST_PASS}
+elif [ -f "${program}.eventlogs" ]; then
+ echo 'too many runtime traces found!' > ${ocamltest_response}
+ exit ${TEST_FAIL}
+else
+ echo 'instrumented runtime trace not found!' > ${ocamltest_response}
+ exit ${TEST_FAIL}
+fi
val y : 'a list -> unit = <fun>
|}];;
-(* this is accepted as all fields are overridden *)
+(* used to be accepted, see PR#7696 *)
let rec x = { x with contents = 3 } [@ocaml.warning "-23"];;
[%%expect{|
-val x : int ref = {contents = 3}
+Line 1, characters 12-35:
+1 | let rec x = { x with contents = 3 } [@ocaml.warning "-23"];;
+ ^^^^^^^^^^^^^^^^^^^^^^^
+Error: This kind of expression is not allowed as right-hand side of `let rec'
|}];;
(* this is rejected as `c` will be dereferenced during the copy,
--- /dev/null
+Error: Failure("Plugin error")
+Raised at Stdlib.failwith in file "stdlib.ml", line 29, characters 17-33
+Called from Test10_plugin.g in file "test10_plugin.ml", line 3, characters 2-21
+Called from Test10_plugin.f in file "test10_plugin.ml", line 6, characters 2-6
+Called from Test10_plugin in file "test10_plugin.ml", line 10, characters 2-6
+Called from Dynlink.Bytecode.run in file "otherlibs/dynlink/dynlink.ml", line 137, characters 16-25
+Re-raised at Dynlink.Bytecode.run in file "otherlibs/dynlink/dynlink.ml", line 139, characters 6-137
+Called from Dynlink_common.Make.load.(fun) in file "otherlibs/dynlink/dynlink_common.ml", line 344, characters 13-44
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Dynlink_common.Make.load in file "otherlibs/dynlink/dynlink_common.ml", line 342, characters 8-240
+Re-raised at Dynlink_common.Make.load in file "otherlibs/dynlink/dynlink_common.ml", line 352, characters 8-17
+Called from Test10_main in file "test10_main.ml", line 51, characters 13-69
--- /dev/null
+(* TEST
+
+include dynlink
+
+files = "test10_plugin.ml"
+flags += "-g"
+
+libraries = ""
+
+* no-flambda
+** shared-libraries
+*** setup-ocamlc.byte-build-env
+**** ocamlc.byte
+module = "test10_main.ml"
+**** ocamlc.byte
+module = "test10_plugin.ml"
+**** ocamlc.byte
+program = "${test_build_directory}/test10.byte"
+libraries = "dynlink"
+all_modules = "test10_main.cmo"
+***** run
+****** check-program-output
+reference = "${test_source_directory}/test10_main.byte.reference"
+
+*** native-dynlink
+**** setup-ocamlopt.byte-build-env
+***** ocamlopt.byte
+module = "test10_main.ml"
+***** ocamlopt.byte
+program = "test10_plugin.cmxs"
+flags = "-shared"
+all_modules = "test10_plugin.ml"
+***** ocamlopt.byte
+program = "${test_build_directory}/test10.exe"
+libraries = "dynlink"
+all_modules = "test10_main.cmx"
+****** run
+******* check-program-output
+reference = "${test_source_directory}/test10_main.native.reference"
+*)
+
+(* Check that a module in the main program whose initializer has not
+ executed completely cannot be depended upon by a shared library being
+ loaded. *)
+
+let () =
+ Printexc.record_backtrace true;
+ try
+ if Dynlink.is_native then begin
+ Dynlink.loadfile "test10_plugin.cmxs"
+ end else begin
+ Dynlink.loadfile "test10_plugin.cmo"
+ end
+ with
+ | Dynlink.Error (Dynlink.Library's_module_initializers_failed exn) ->
+ Printf.eprintf "Error: %s\n%!" (Printexc.to_string exn);
+ Printexc.print_backtrace stderr
--- /dev/null
+Error: Failure("Plugin error")
+Raised at Stdlib.failwith in file "stdlib.ml", line 29, characters 17-33
+Called from Test10_plugin.g in file "test10_plugin.ml", line 2, characters 15-38
+Called from Test10_plugin in file "test10_plugin.ml", line 10, characters 2-6
+Called from Dynlink.Native.run.(fun) in file "otherlibs/dynlink/native/dynlink.ml", line 85, characters 12-29
+Called from Dynlink.Native.run.(fun) in file "otherlibs/dynlink/native/dynlink.ml", line 85, characters 12-29
+Re-raised at Dynlink.Native.run.(fun) in file "otherlibs/dynlink/native/dynlink.ml", line 87, characters 10-149
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Dynlink_common.Make.load.(fun) in file "otherlibs/dynlink/dynlink_common.ml", line 344, characters 13-44
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Dynlink_common.Make.load in file "otherlibs/dynlink/dynlink_common.ml", line 342, characters 8-240
+Re-raised at Dynlink_common.Make.load in file "otherlibs/dynlink/dynlink_common.ml", line 352, characters 8-17
+Called from Dynlink_common.Make.loadfile in file "otherlibs/dynlink/dynlink_common.ml" (inlined), line 354, characters 26-45
+Called from Test10_main in file "test10_main.ml", line 49, characters 30-87
--- /dev/null
+let g () =
+ if true then failwith "Plugin error";
+ print_endline "xxx"
+
+let f () =
+ g ();
+ print_endline "xxx"
+
+let () =
+ f ();
+ print_endline "xxx"
--- /dev/null
+(* TEST
+*)
+
+(* See https://github.com/ocaml/ocaml/issues/9460
+ This test comes from Richard Jones
+ at
+ https://github.com/libguestfs/libnbd/blob/0475bfe04a527051c0a37af59a733c4c8554e427/ocaml/tests/test_400_pread.ml#L21-L36
+*)
+let test_result =
+ let b = Bytes.create 16 in
+ for i = 0 to 16/8-1 do
+ let i64 = ref (Int64.of_int (i*8)) in
+ for j = 0 to 7 do
+ let c = Int64.shift_right_logical !i64 56 in
+ let c = Int64.to_int c in
+ let c = Char.chr c in
+ Bytes.unsafe_set b (i*8+j) c;
+ i64 := Int64.shift_left !i64 8
+ done
+ done;
+ (Bytes.to_string b) ;;
+
+let expected =
+ "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008"
+
+let () =
+ assert (test_result = expected)
+
+(* Reproduction case by Jeremy Yallop in
+ https://github.com/ocaml/ocaml/pull/9463#issuecomment-615831765
+*)
+let () =
+ let x = ref Int64.max_int in
+ assert (!x = Int64.max_int)
+
+let () =
+ print_endline "OK"
(* Standard test case *)
let () =
let l = List.init 10 (fun x -> x) in
+ let sl = List.init 10 string_of_int in
assert (List.exists (fun a -> a < 10) l);
assert (List.exists (fun a -> a > 0) l);
assert (List.exists (fun a -> a = 0) l);
assert (List.find_map (f ~limit:30) l = None);
end;
+ assert (List.filteri (fun i _ -> i < 2) (List.rev l) = [9; 8]);
+
assert (List.compare_lengths [] [] = 0);
assert (List.compare_lengths [1;2] ['a';'b'] = 0);
assert (List.compare_lengths [] [1;2] < 0);
assert (
let count = ref 0 in
List.concat_map (fun i -> incr count; [i; !count]) [1; 5] = [1; 1; 5; 2]);
+ assert (List.fold_left_map (fun a b -> a + b, b) 0 l = (45, l));
+ assert (List.fold_left_map (fun a b -> assert false) 0 [] = (0, []));
+ assert (
+ let f a b = a + b, string_of_int b in
+ List.fold_left_map f 0 l = (45, sl));
()
;;
--- /dev/null
+(* TEST *)
+
+let () =
+ let small = 0xfffe and large = 0xffff in
+ let marshalled dim =
+ let ba = Bigarray.(Array1.create int8_unsigned c_layout dim) in
+ Marshal.to_string ba []
+ in
+ (* Bigarray dimension marshalling scheme: use an extra 8 bytes
+ to marshal dimensions >=0xffff to avoid overflow *)
+ assert
+ (((String.length (marshalled large) - String.length (marshalled small))
+ - (large - small))
+ = 8)
()
;;
+(* unfold *)
+let () =
+ let range first last =
+ let step i = if i > last then None
+ else Some (i, succ i) in
+ Seq.unfold step first
+ in
+ begin
+ assert ([1;2;3] = List.of_seq (range 1 3));
+ assert ([] = List.of_seq (range 1 0));
+ end
+;;
+
(* MPR 7820 *)
let () =
assert
(let p x y = x >= 3 && x <= 6 in
M.bindings(M.filter p s1) = List.filter (uncurry p) (M.bindings s1));
+ checkbool "filter_map"
+ (let f x y = if x >= 3 && x <= 6 then Some (2 * x) else None in
+ let f_on_pair (x, y) = Option.map (fun v -> (x, v)) (f x y) in
+ M.bindings(M.filter_map f s1) = List.filter_map f_on_pair (M.bindings s1));
+
checkbool "partition"
(let p x y = x >= 3 && x <= 6 in
let (st,sf) = M.partition p s1
(let p x = x >= 3 && x <= 6 in
S.elements(S.filter p s1) = List.filter p (S.elements s1));
+ checkbool "filter_map"
+ (let f x = if x >= 3 && x <= 6 then Some (2 * x) else None in
+ S.elements(S.filter_map f s1) = List.filter_map f (S.elements s1));
+
+ checkbool "filter_map(==)"
+ (let f x = Some x in
+ S.filter_map f s1 == s1);
+
checkbool "partition"
(let p x = x >= 3 && x <= 6 in
let (st,sf) = S.partition p s1
let _, exit = waitpid [] pid in
assert (exit = WEXITED 0)
+let exec args =
+ execv ("./" ^ prog_name) (Array.of_list (prog_name :: args))
+
let () =
List.iter run
[
[" \\ \\ \\\\\\"];
[" \"hola \""];
["a\tb"];
- ]
+ ];
+ Printf.printf "-- execv\n%!";
+ exec [
+ "";
+ "a"; "b"; "c.txt@!";
+ "\"";
+ " "; " a "; " \" \\\" ";
+ " \\ \\ \\\\\\";
+ " \"hola \"";
+ "a\tb"
+ ]
" \\ \\ \\\\\\" -> " \\ \\ \\\\\\" [OK]
" \"hola \"" -> " \"hola \"" [OK]
"a\tb" -> "a\tb" [OK]
+-- execv
+
+a
+b
+c.txt@!
+"
+
+ a
+ " \"
+ \ \ \\\
+ "hola "
+a b
--- /dev/null
+(* TEST
+ flags = "-I ${ocamlsrcdir}/utils"
+ * expect
+*)
+
+(* Strict-sequence can change the behavior of programs *)
+
+(* The two examples below were proposed by Jeremy Yallop in
+ https://github.com/ocaml/ocaml/pull/1971 .
+ Note that those tests are here to record this behavior and not to enshrine it.
+*)
+
+[@@@warning "-10-18-8-5"];;
+type t = A | () and b = B : _ -> b;;
+[%%expect{|
+type t = A | ()
+and b = B : 'a -> b
+|}];;
+
+Clflags.strict_sequence := false ;;
+let f (g : 'a) = g; Format.printf "%b@." (B (() : 'a) = B A) in f ();;
+[%%expect {|
+- : unit = ()
+false
+- : unit = ()
+|}]
+;;
+
+Clflags.strict_sequence := true ;;
+let f (g : 'a) = g; Format.printf "%b@." (B (() : 'a) = B A) in f ();;
+[%%expect {|
+- : unit = ()
+true
+- : unit = ()
+|}]
+;;
+
+Clflags.strict_sequence := false;;
+let f () = let g ~y = (raise Not_found : 'a) in
+ if false then ((assert false : 'a); g ()) else g ()
+let _ = Format.printf "%b@." (try f (); false with Not_found -> true)
+[%%expect {|
+- : unit = ()
+val f : t -> y:'a -> 'b = <fun>
+false
+- : unit = ()
+|}]
+;;
+
+Clflags.strict_sequence := true ;;
+let f () = let g ~y = (raise Not_found : 'a) in
+ if false then ((assert false : 'a); g ()) else g ()
+let _ = Format.printf "%b@." (try f (); false with Not_found -> true)
+[%%expect {|
+- : unit = ()
+val f : t -> unit = <fun>
+true
+- : unit = ()
+|}]
--- /dev/null
+(* TEST
+flags = "-I ${ocamlsrcdir}/parsing -I ${ocamlsrcdir}/toplevel"
+include ocamlcommon
+*)
+let position = Lexing.{ (* This corresponds to File "file.ml", line 100, character 10 *)
+ pos_fname = "------should not appear------";
+ pos_lnum = 100;
+ pos_bol = 1000;
+ pos_cnum = 1010;
+}
+
+(* We need to show, that just changing lex_curr_p is not enough.
+ See wrong columns in output for 'Incomplete version'. *)
+let set_position_incomplete lexbuf position =
+ let open Lexing in
+ lexbuf.lex_curr_p <- {position with pos_fname = lexbuf.lex_curr_p.pos_fname}
+
+(* "Testing framework" *)
+let print_error_in_parse set_position_variant =
+ try
+ let _ =
+ let lexbuf = Lexing.from_string ")f x" in (* contains error in chars 0-1, line 0 *)
+ set_position_variant lexbuf position;
+ Lexing.set_filename lexbuf "file.ml"; (* also testing set_filename *)
+ Parse.expression lexbuf in ()
+ with e -> Location.report_exception Format.std_formatter e
+
+let _ =
+ print_string "Incomplete version:\n";
+ print_error_in_parse set_position_incomplete;
+ print_string "Good version:\n";
+ print_error_in_parse Lexing.set_position
--- /dev/null
+Incomplete version:
+File "file.ml", line 100, characters 10--999:
+Error: Syntax error
+Good version:
+File "file.ml", line 100, characters 10-11:
+Error: Syntax error
structure_item (extensions.ml[10,176+40]..[10,176+45])
Pstr_eval
expression (extensions.ml[10,176+40]..[10,176+45])
- Pexp_constant PConst_string("foo",None)
+ Pexp_constant PConst_string("foo",(extensions.ml[10,176+41]..[10,176+44]),None)
]
]
structure_item (extensions.ml[12,224+0]..[12,224+26])
--- /dev/null
+[
+ structure_item (quotedextensions.ml[10,170+0]..[10,170+23])
+ Pstr_extension "M.foo"
+ [
+ structure_item (quotedextensions.ml[10,170+0]..[10,170+23]) ghost
+ Pstr_eval
+ expression (quotedextensions.ml[10,170+0]..[10,170+23]) ghost
+ Pexp_constant PConst_string (" <hello>{x} ",(quotedextensions.ml[10,170+9]..[10,170+21]),Some "")
+ ]
+ structure_item (quotedextensions.ml[11,194+0]..[11,194+32])
+ Pstr_extension "M.foo"
+ [
+ structure_item (quotedextensions.ml[11,194+0]..[11,194+32]) ghost
+ Pstr_eval
+ expression (quotedextensions.ml[11,194+0]..[11,194+32]) ghost
+ Pexp_constant PConst_string (" <hello>{|x|} ",(quotedextensions.ml[11,194+13]..[11,194+27]),Some "bar")
+ ]
+ structure_item (quotedextensions.ml[14,245+0]..[17,326+3])
+ Pstr_modtype "S" (quotedextensions.ml[14,245+12]..[14,245+13])
+ module_type (quotedextensions.ml[14,245+16]..[17,326+3])
+ Pmty_signature
+ [
+ signature_item (quotedextensions.ml[15,265+2]..[15,265+25])
+ Psig_extension "M.foo"
+ [
+ structure_item (quotedextensions.ml[15,265+2]..[15,265+25]) ghost
+ Pstr_eval
+ expression (quotedextensions.ml[15,265+2]..[15,265+25]) ghost
+ Pexp_constant PConst_string (" <hello>{x} ",(quotedextensions.ml[15,265+11]..[15,265+23]),Some "")
+ ]
+ signature_item (quotedextensions.ml[16,291+2]..[16,291+34])
+ Psig_extension "M.foo"
+ [
+ structure_item (quotedextensions.ml[16,291+2]..[16,291+34]) ghost
+ Pstr_eval
+ expression (quotedextensions.ml[16,291+2]..[16,291+34]) ghost
+ Pexp_constant PConst_string (" <hello>{|x|} ",(quotedextensions.ml[16,291+15]..[16,291+29]),Some "bar")
+ ]
+ ]
+ structure_item (quotedextensions.ml[20,363+0]..[22,417+26])
+ Pstr_value Nonrec
+ [
+ <def>
+ pattern (quotedextensions.ml[20,363+4]..[21,390+26]) ghost
+ Ppat_constraint
+ pattern (quotedextensions.ml[20,363+4]..[20,363+26])
+ Ppat_extension "M.foo"
+ [
+ structure_item (quotedextensions.ml[20,363+4]..[20,363+26]) ghost
+ Pstr_eval
+ expression (quotedextensions.ml[20,363+4]..[20,363+26]) ghost
+ Pexp_constant PConst_string (" <hello>{x} ",(quotedextensions.ml[20,363+12]..[20,363+24]),Some "")
+ ]
+ core_type (quotedextensions.ml[21,390+4]..[21,390+26])
+ Ptyp_extension "M.foo"
+ [
+ structure_item (quotedextensions.ml[21,390+4]..[21,390+26]) ghost
+ Pstr_eval
+ expression (quotedextensions.ml[21,390+4]..[21,390+26]) ghost
+ Pexp_constant PConst_string (" <hello>{x} ",(quotedextensions.ml[21,390+12]..[21,390+24]),Some "")
+ ]
+ expression (quotedextensions.ml[22,417+4]..[22,417+26])
+ Pexp_extension "M.foo"
+ [
+ structure_item (quotedextensions.ml[22,417+4]..[22,417+26]) ghost
+ Pstr_eval
+ expression (quotedextensions.ml[22,417+4]..[22,417+26]) ghost
+ Pexp_constant PConst_string (" <hello>{x} ",(quotedextensions.ml[22,417+12]..[22,417+24]),Some "")
+ ]
+ ]
+ structure_item (quotedextensions.ml[23,444+0]..[25,516+35])
+ Pstr_value Nonrec
+ [
+ <def>
+ pattern (quotedextensions.ml[23,444+4]..[24,480+35]) ghost
+ Ppat_constraint
+ pattern (quotedextensions.ml[23,444+4]..[23,444+35])
+ Ppat_extension "M.foo"
+ [
+ structure_item (quotedextensions.ml[23,444+4]..[23,444+35]) ghost
+ Pstr_eval
+ expression (quotedextensions.ml[23,444+4]..[23,444+35]) ghost
+ Pexp_constant PConst_string (" <hello>{|x|} ",(quotedextensions.ml[23,444+16]..[23,444+30]),Some "bar")
+ ]
+ core_type (quotedextensions.ml[24,480+4]..[24,480+35])
+ Ptyp_extension "M.foo"
+ [
+ structure_item (quotedextensions.ml[24,480+4]..[24,480+35]) ghost
+ Pstr_eval
+ expression (quotedextensions.ml[24,480+4]..[24,480+35]) ghost
+ Pexp_constant PConst_string (" <hello>{|x|} ",(quotedextensions.ml[24,480+16]..[24,480+30]),Some "bar")
+ ]
+ expression (quotedextensions.ml[25,516+4]..[25,516+35])
+ Pexp_extension "M.foo"
+ [
+ structure_item (quotedextensions.ml[25,516+4]..[25,516+35]) ghost
+ Pstr_eval
+ expression (quotedextensions.ml[25,516+4]..[25,516+35]) ghost
+ Pexp_constant PConst_string (" <hello>{|x|} ",(quotedextensions.ml[25,516+16]..[25,516+30]),Some "bar")
+ ]
+ ]
+ structure_item (quotedextensions.ml[28,569+0]..[32,605+2])
+ Pstr_extension "M.foo"
+ [
+ structure_item (quotedextensions.ml[28,569+0]..[32,605+2]) ghost
+ Pstr_eval
+ expression (quotedextensions.ml[28,569+0]..[32,605+2]) ghost
+ Pexp_constant PConst_string ("\n <hello>\n {x}\n </hello>\n",(quotedextensions.ml[28,569+9]..[32,605+0]),Some "")
+ ]
+]
+
+File "quotedextensions.ml", line 10, characters 3-8:
+10 | {%%M.foo| <hello>{x} |}
+ ^^^^^
+Error: Uninterpreted extension 'M.foo'.
--- /dev/null
+(* TEST
+ flags = "-dparsetree"
+ ocamlc_byte_exit_status = "2"
+ * setup-ocamlc.byte-build-env
+ ** ocamlc.byte
+ *** check-ocamlc.byte-output
+*)
+
+(* Structures *)
+{%%M.foo| <hello>{x} |}
+{%%M.foo bar| <hello>{|x|} |bar}
+
+(* Signatures *)
+module type S = sig
+ {%%M.foo| <hello>{x} |}
+ {%%M.foo bar| <hello>{|x|} |bar}
+end
+
+(* Expressions/Pattern/Types *)
+let {%M.foo| <hello>{x} |}
+ : {%M.foo| <hello>{x} |}
+ = {%M.foo| <hello>{x} |}
+let {%M.foo bar| <hello>{|x|} |bar}
+ : {%M.foo bar| <hello>{|x|} |bar}
+ = {%M.foo bar| <hello>{|x|} |bar}
+
+(* Multiline *)
+{%%M.foo|
+ <hello>
+ {x}
+ </hello>
+|}
+
+(* Double quotes inside quoted strings inside comments *)
+(* {|"|}, and *)
+(* [%foo {|"|}], and *)
+(* {%foo|"|} should be valid inside comments *)
+
+(* Comment delimiters inside quoted strings inside comments: *)
+(* {|*)|}, and *)
+(* [%foo {bar|*)|bar}], and *)
+(* {%foo bar|*)|bar} should be valid inside comments *)
--- /dev/null
+(* TEST *)
+
+(* This function uses a ref initially holding an immediate (None),
+ which is later mutated to hold a pointer (Some ...). Despite
+ initially holding an immediate, the register used must be marked
+ in the frametable.
+
+ This was previously done by distinguishing Const_pointer (values
+ like None from a type that also contains pointers) from Const_int
+ (values like 0 from a type that contains no pointers), but is
+ now done by preserving typing information about the ref. *)
+
+let no_magic b =
+ let r = ref None in
+ for i = 1 to 10 do
+ let z = if b then !r else None in
+ Gc.minor ();
+ r := Some (String.make i '.');
+ (match z with None -> () | Some s -> print_endline s)
+ done
+
+
+(* This version is the same, except uses Obj.magic 0 instead of None.
+ This segfaulted when the Const_pointer / Const_int distinction
+ was used for register typing, as Obj.magic 0 is a Const_int *)
+
+let light_magic b =
+ let none = (Obj.magic 0 : string option) in
+ let r = ref none in
+ for i = 1 to 10 do
+ let z = if b then !r else none in
+ Gc.minor ();
+ r := Some (String.make i '.');
+ (match z with None -> () | Some s -> print_endline s)
+ done
+
+
+(* This version stores references to heap values inside an `int ref`,
+ which is eliminated and the resulting register is not marked in
+ the frametable. This is not expected to work, segfaults on all
+ versions, and is included here only to document what not to do. *)
+
+let dark_magic b =
+ let none = 0 in
+ let r = ref 0 in
+ for i = 1 to 10 do
+ let z : string option = Obj.magic (if b then !r else none) in
+ Gc.minor ();
+ r := Obj.magic (Some (String.make i '.'));
+ (match z with None -> () | Some s -> print_endline s)
+ done
+
+
+let () =
+ Sys.opaque_identity no_magic true;
+ Sys.opaque_identity light_magic true
--- /dev/null
+.
+..
+...
+....
+.....
+......
+.......
+........
+.........
+.
+..
+...
+....
+.....
+......
+.......
+........
+.........
external test_alloc : unit -> t = "caml_test_pr3612_alloc"
external get_counter : unit -> int = "caml_test_pr3612_counter"
-(* The number of deserialized blocs minus the number of freed blocs *)
+(* The number of deserialized blocks minus the number of freed blocks *)
external init : unit -> unit = "caml_test_pr3612_init"
--- /dev/null
+(* TEST *)
+
+let go () =
+ Gc.full_major ();
+ for i = 1 to 10_000 do
+ let rec b =
+ let x = (b, b) in
+ (* Force the above allocation to be live across a GC,
+ by allocating a large enough object that the allocations
+ cannot be combined. *)
+ let x = [| x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x;
+ x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x;
+ x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x;
+ x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x;
+ x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x;
+ x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x;
+ x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x;
+ x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x;
+ x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x;
+ x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x;
+ x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x;
+ x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x;
+ x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x;
+ x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x;
+ x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x;
+ x; x; x; x; x; x; x; x; x; x; x; x; x; x; x; x;
+ x |] in
+ let _y = ref x in
+ 42 in
+ ignore (Sys.opaque_identity b);
+ ()
+ done;
+ ()
+
+let _ =
+ let _ = go () in
+ print_endline "ok"
--- /dev/null
+(* TEST *)
+
+(* Test tail call optimisation with an elided mutable cell *)
+let rec loop n =
+ if n = 0 then () else begin
+ let last = ref 0 in
+ last := 0;
+ loop (n-1)
+ end
+
+let () = loop 1_000_000
--- /dev/null
+(* TEST
+ files = "cmis_on_file_system.ml cmis_on_file_system_companion.mli"
+ * setup-ocamlc.byte-build-env
+ ** ocamlc.byte
+ compile_only = "true"
+ module = "cmis_on_file_system.ml"
+ flags="-bin-annot"
+ *** script
+ script= "mv cmis_on_file_system.cmt lone.cmt"
+ **** ocamlc.byte
+ module = "cmis_on_file_system_companion.mli"
+ compile_only="true"
+ ***** ocamlc.byte
+ compile_only = "true"
+ flags="-bin-annot"
+ module="cmis_on_file_system.ml"
+ ****** compare-native-programs
+ program="cmis_on_file_system.cmt"
+ program2="lone.cmt"
+*)
+
+
+(** Test that we are not recording the cmis present on the file system
+ at a given point in time *)
+type t = int
+let () = ()
--- /dev/null
+(* TEST
+ flags = "-g"
+ compare_programs = "false"
+*)
+
+open Gc.Memprof
+
+let root = ref []
+let[@inline never] allocate_arrays lo hi cnt keep =
+ assert (lo >= 300); (* Will be allocated in major heap. *)
+ for j = 0 to cnt-1 do
+ for i = lo to hi do
+ root := Array.make i 0 :: !root
+ done;
+ if not keep then root := []
+ done
+
+let check_nosample () =
+ Printf.printf "check_nosample\n%!";
+ let alloc _ =
+ Printf.printf "Callback called with sampling_rate = 0\n";
+ assert(false)
+ in
+ start ~callstack_size:10 ~sampling_rate:0.
+ { null_tracker with alloc_minor = alloc; alloc_major = alloc; };
+ allocate_arrays 300 3000 1 false;
+ stop ()
+
+let () = check_nosample ()
+
+let check_counts_full_major force_promote =
+ Printf.printf "check_counts_full_major\n%!";
+ let nalloc_minor = ref 0 in
+ let nalloc_major = ref 0 in
+ let enable = ref true in
+ let npromote = ref 0 in
+ let ndealloc_minor = ref 0 in
+ let ndealloc_major = ref 0 in
+ start ~callstack_size:10 ~sampling_rate:0.01
+ {
+ alloc_minor = (fun _ ->
+ if not !enable then None
+ else Some (incr nalloc_minor)
+ );
+ alloc_major = (fun _ ->
+ if not !enable then None
+ else Some (incr nalloc_major)
+ );
+ promote = (fun _ ->
+ Some (incr npromote)
+ );
+ dealloc_minor = (fun _ ->
+ incr ndealloc_minor
+ );
+ dealloc_major = (fun _ ->
+ incr ndealloc_major
+ );
+ };
+ allocate_arrays 300 3000 1 true;
+ enable := false;
+ assert (!ndealloc_minor = 0 && !ndealloc_major = 0);
+ if force_promote then begin
+ Gc.full_major ();
+ assert (!ndealloc_minor = 0 && !ndealloc_major = 0 &&
+ !npromote = !nalloc_minor);
+ root := [];
+ Gc.full_major ();
+ assert (!ndealloc_minor = 0 &&
+ !ndealloc_major = !nalloc_minor + !nalloc_major);
+ end else begin
+ root := [];
+ Gc.minor ();
+ Gc.full_major ();
+ Gc.full_major ();
+ assert (!nalloc_minor = !ndealloc_minor + !npromote &&
+ !ndealloc_major = !npromote + !nalloc_major)
+ end;
+ stop ()
+
+let () =
+ check_counts_full_major false;
+ check_counts_full_major true
+
+let check_no_nested () =
+ Printf.printf "check_no_nested\n%!";
+ let in_callback = ref false in
+ let cb _ =
+ assert (not !in_callback);
+ in_callback := true;
+ allocate_arrays 300 300 100 false;
+ in_callback := false;
+ ()
+ in
+ let cb' _ = cb (); Some () in
+ start ~callstack_size:10 ~sampling_rate:1.
+ {
+ alloc_minor = cb';
+ alloc_major = cb';
+ promote = cb';
+ dealloc_minor = cb;
+ dealloc_major = cb;
+ };
+ allocate_arrays 300 300 100 false;
+ stop ()
+
+let () = check_no_nested ()
+
+let check_distrib lo hi cnt rate =
+ Printf.printf "check_distrib %d %d %d %f\n%!" lo hi cnt rate;
+ let smp = ref 0 in
+ start ~callstack_size:10 ~sampling_rate:rate
+ { null_tracker with
+ alloc_major = (fun info ->
+ assert (info.size >= lo && info.size <= hi);
+ assert (info.n_samples > 0);
+ assert (not info.unmarshalled);
+ smp := !smp + info.n_samples;
+ None
+ );
+ };
+ allocate_arrays lo hi cnt false;
+ stop ();
+
+ (* The probability distribution of the number of samples follows a
+ binomial distribution of parameters tot_alloc and rate. Given
+ that tot_alloc*rate and tot_alloc*(1-rate) are large (i.e., >
+ 100), this distribution is approximately equal to a normal
+ distribution. We compute a 1e-8 confidence interval for !smp
+ using quantiles of the normal distribution, and check that we are
+ in this confidence interval. *)
+ let tot_alloc = cnt*(lo+hi+2)*(hi-lo+1)/2 in
+ assert (float tot_alloc *. rate > 100. &&
+ float tot_alloc *. (1. -. rate) > 100.);
+ let mean = float tot_alloc *. rate in
+ let stddev = sqrt (float tot_alloc *. rate *. (1. -. rate)) in
+ (* This assertion has probability to fail close to 1e-8. *)
+ assert (abs_float (mean -. float !smp) <= stddev *. 5.7)
+
+let () =
+ check_distrib 300 3000 3 0.00001;
+ check_distrib 300 3000 1 0.0001;
+ check_distrib 300 3000 1 0.01;
+ check_distrib 300 3000 1 0.9;
+ check_distrib 300 300 100000 0.1;
+ check_distrib 300000 300000 30 0.1
+
+let () =
+ Printf.printf "OK !\n"
--- /dev/null
+check_nosample
+check_counts_full_major
+check_counts_full_major
+check_no_nested
+check_distrib 300 3000 3 0.000010
+check_distrib 300 3000 1 0.000100
+check_distrib 300 3000 1 0.010000
+check_distrib 300 3000 1 0.900000
+check_distrib 300 300 100000 0.100000
+check_distrib 300000 300000 30 0.100000
+OK !
--- /dev/null
+(* TEST
+ flags = "-g"
+ compare_programs = "false"
+*)
+
+open Gc.Memprof
+
+let roots = Array.make 1000000 [||]
+let roots_pos = ref 0
+let add_root r =
+ roots.(!roots_pos) <- r;
+ incr roots_pos
+let clear_roots () =
+ Array.fill roots 0 !roots_pos [||];
+ roots_pos := 0
+
+let[@inline never] allocate_arrays lo hi cnt keep =
+ assert (0 < lo && hi <= 250); (* Fits in minor heap. *)
+ for j = 0 to cnt-1 do
+ for i = lo to hi do
+ add_root (Array.make i 0)
+ done;
+ if not keep then clear_roots ()
+ done
+
+let check_nosample () =
+ Printf.printf "check_nosample\n%!";
+ let alloc _ =
+ Printf.printf "Callback called with sampling_rate = 0\n";
+ assert(false)
+ in
+ start ~callstack_size:10 ~sampling_rate:0.
+ { null_tracker with alloc_minor = alloc; alloc_major = alloc };
+ allocate_arrays 1 250 100 false;
+ stop ()
+
+let () = check_nosample ()
+
+let check_counts_full_major force_promote =
+ Printf.printf "check_counts_full_major\n%!";
+ let nalloc_minor = ref 0 in
+ let enable = ref true in
+ let promotes_allowed = ref true in
+ let npromote = ref 0 in
+ let ndealloc_minor = ref 0 in
+ let ndealloc_major = ref 0 in
+ start ~callstack_size:10 ~sampling_rate:0.01
+ {
+ alloc_minor = (fun info ->
+ if !enable then begin
+ incr nalloc_minor; if !nalloc_minor mod 100 = 0 then Gc.minor ();
+ Some (ref 42)
+ end else begin
+ allocate_arrays 1 250 1 true;
+ None
+ end);
+ alloc_major = (fun _ -> assert false);
+ promote = (fun k ->
+ assert (!k = 42 && !promotes_allowed);
+ incr npromote; if !npromote mod 1097 = 0 then Gc.minor ();
+ Some (ref 17));
+ dealloc_minor = (fun k ->
+ assert (!k = 42);
+ incr ndealloc_minor);
+ dealloc_major = (fun r ->
+ assert (!r = 17);
+ incr ndealloc_major);
+ };
+ allocate_arrays 1 250 100 true;
+ enable := false;
+ assert (!ndealloc_minor = 0 && !ndealloc_major = 0);
+ if force_promote then begin
+ Gc.full_major ();
+ promotes_allowed := false;
+ allocate_arrays 1 250 10 true;
+ Gc.full_major ();
+ assert (!ndealloc_minor = 0 && !ndealloc_major = 0 &&
+ !npromote = !nalloc_minor);
+ clear_roots ();
+ Gc.full_major ();
+ assert (!ndealloc_minor = 0 && !ndealloc_major = !nalloc_minor);
+ end else begin
+ clear_roots ();
+ Gc.minor ();
+ Gc.full_major ();
+ Gc.full_major ();
+ assert (!nalloc_minor = !ndealloc_minor + !npromote &&
+ !ndealloc_major = !npromote)
+ end;
+ stop ()
+
+let () =
+ check_counts_full_major false;
+ check_counts_full_major true
+
+let check_no_nested () =
+ Printf.printf "check_no_nested\n%!";
+ let in_callback = ref false in
+ let cb _ =
+ assert (not !in_callback);
+ in_callback := true;
+ allocate_arrays 1 100 10 false;
+ ignore (Array.to_list (Array.make 1000 0));
+ in_callback := false;
+ ()
+ in
+ let cb' _ = cb (); Some () in
+ start ~callstack_size:10 ~sampling_rate:1.
+ {
+ alloc_minor = cb';
+ alloc_major = cb';
+ promote = cb';
+ dealloc_minor = cb;
+ dealloc_major = cb;
+ };
+ allocate_arrays 1 250 5 false;
+ stop ()
+
+let () = check_no_nested ()
+
+let check_distrib lo hi cnt rate =
+ Printf.printf "check_distrib %d %d %d %f\n%!" lo hi cnt rate;
+ let smp = ref 0 in
+ start ~callstack_size:10 ~sampling_rate:rate
+ { null_tracker with
+ alloc_major = (fun _ -> assert false);
+ alloc_minor = (fun info ->
+ assert (info.size >= lo && info.size <= hi);
+ assert (info.n_samples > 0);
+ assert (not info.unmarshalled);
+ smp := !smp + info.n_samples;
+ None
+ );
+ };
+ allocate_arrays lo hi cnt false;
+ stop ();
+
+ (* The probability distribution of the number of samples follows a
+ binomial distribution of parameters tot_alloc and rate. Given
+ that tot_alloc*rate and tot_alloc*(1-rate) are large (i.e., >
+ 100), this distribution is approximately equal to a normal
+ distribution. We compute a 1e-8 confidence interval for !smp
+ using quantiles of the normal distribution, and check that we are
+ in this confidence interval. *)
+ let tot_alloc = cnt*(lo+hi+2)*(hi-lo+1)/2 in
+ assert (float tot_alloc *. rate > 100. &&
+ float tot_alloc *. (1. -. rate) > 100.);
+ let mean = float tot_alloc *. rate in
+ let stddev = sqrt (float tot_alloc *. rate *. (1. -. rate)) in
+ (* This assertion has probability to fail close to 1e-8. *)
+ assert (abs_float (mean -. float !smp) <= stddev *. 5.7)
+
+let () =
+ check_distrib 1 250 1000 0.00001;
+ check_distrib 1 250 1000 0.0001;
+ check_distrib 1 250 1000 0.01;
+ check_distrib 1 250 1000 0.9;
+ check_distrib 1 1 10000000 0.01;
+ check_distrib 250 250 100000 0.1
+
+let () =
+ Printf.printf "OK !\n"
--- /dev/null
+check_nosample
+check_counts_full_major
+check_counts_full_major
+check_no_nested
+check_distrib 1 250 1000 0.000010
+check_distrib 1 250 1000 0.000100
+check_distrib 1 250 1000 0.010000
+check_distrib 1 250 1000 0.900000
+check_distrib 1 1 10000000 0.010000
+check_distrib 250 250 100000 0.100000
+OK !
--- /dev/null
+(* TEST
+* hassysthreads
+include systhreads
+** bytecode
+** native
+*)
+
+let cnt = ref 0
+let alloc_num = ref 0
+let alloc_tot = 100000
+
+let (rd1, wr1) = Unix.pipe ()
+let (rd2, wr2) = Unix.pipe ()
+
+let main_thread = Thread.self ()
+let cb_main = ref 0 and cb_other = ref 0
+let stopped = ref false
+let minor_alloc_callback _ =
+ if !stopped then
+ None
+ else begin
+ let do_stop = !cb_main + !cb_other >= alloc_tot in
+ if do_stop then stopped := true;
+ let t = Thread.self () in
+ if t == main_thread then begin
+ incr cb_main;
+ assert (Unix.write wr2 (Bytes.make 1 'a') 0 1 = 1);
+ if not do_stop then
+ assert (Unix.read rd1 (Bytes.make 1 'a') 0 1 = 1)
+ end else begin
+ incr cb_other;
+ assert (Unix.write wr1 (Bytes.make 1 'a') 0 1 = 1);
+ if not do_stop then
+ assert (Unix.read rd2 (Bytes.make 1 'a') 0 1 = 1)
+ end;
+ Some ()
+ end
+
+let mut = Mutex.create ()
+let () = Mutex.lock mut
+
+let rec go () =
+ Mutex.lock mut;
+ Mutex.unlock mut;
+ if !alloc_num < alloc_tot then begin
+ alloc_num := !alloc_num + 1;
+ Sys.opaque_identity (Bytes.make (Random.int 300) 'a') |> ignore;
+ go ()
+ end else begin
+ cnt := !cnt + 1;
+ if !cnt < 2 then begin
+ Gc.minor (); (* check for callbacks *)
+ Thread.yield ();
+ go ()
+ end else begin
+ Gc.minor () (* check for callbacks *)
+ end
+ end
+
+let () =
+ let t = Thread.create go () in
+ Gc.Memprof.(start ~callstack_size:10 ~sampling_rate:1.
+ { null_tracker with alloc_minor = minor_alloc_callback; });
+ Mutex.unlock mut;
+ go ();
+ Thread.join t;
+ Gc.Memprof.stop ();
+ assert (abs (!cb_main - !cb_other) <= 1);
+ assert (!cb_main + !cb_other >= alloc_tot)
--- /dev/null
+-----------
+Raised by primitive operation at Callstacks.alloc_list_literal in file "callstacks.ml", line 19, characters 30-53
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_pair in file "callstacks.ml", line 22, characters 30-76
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_record in file "callstacks.ml", line 27, characters 12-66
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_some in file "callstacks.ml", line 30, characters 30-60
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_array_literal in file "callstacks.ml", line 33, characters 30-55
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_float_array_literal in file "callstacks.ml", line 37, characters 12-62
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.do_alloc_unknown_array_literal in file "callstacks.ml", line 40, characters 22-27
+Called from Callstacks.alloc_unknown_array_literal in file "callstacks.ml", line 42, characters 30-65
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_small_array in file "callstacks.ml", line 45, characters 30-69
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_large_array in file "callstacks.ml", line 48, characters 30-73
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_closure.(fun) in file "callstacks.ml", line 52, characters 30-43
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.get0 in file "callstacks.ml", line 55, characters 28-33
+Called from Callstacks.getfloatfield in file "callstacks.ml", line 57, characters 30-47
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Stdlib__marshal.from_bytes in file "marshal.ml", line 61, characters 9-35
+Called from Callstacks.alloc_unmarshal in file "callstacks.ml", line 63, characters 12-87
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_ref in file "callstacks.ml", line 66, characters 30-59
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.prod_floats in file "callstacks.ml", line 69, characters 37-43
+Called from Callstacks.alloc_boxedfloat in file "callstacks.ml", line 71, characters 30-49
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
--- /dev/null
+(* TEST
+ flags = "-g -w -5"
+ compare_programs = "false"
+
+ * flat-float-array
+ reference = "${test_source_directory}/callstacks.flat-float-array.reference"
+ ** native
+ ** bytecode
+
+ * no-flat-float-array
+ reference = "${test_source_directory}/callstacks.no-flat-float-array.reference"
+ ** native
+ ** bytecode
+*)
+
+open Gc.Memprof
+
+let alloc_list_literal () =
+ ignore (Sys.opaque_identity [Sys.opaque_identity 1])
+
+let alloc_pair () =
+ ignore (Sys.opaque_identity (Sys.opaque_identity 1, Sys.opaque_identity 2))
+
+type record = { a : int; b : int }
+let alloc_record () =
+ ignore (Sys.opaque_identity
+ {a = Sys.opaque_identity 1; b = Sys.opaque_identity 2})
+
+let alloc_some () =
+ ignore (Sys.opaque_identity (Some (Sys.opaque_identity 2)))
+
+let alloc_array_literal () =
+ ignore (Sys.opaque_identity [|Sys.opaque_identity 1|])
+
+let alloc_float_array_literal () =
+ ignore (Sys.opaque_identity
+ [|Sys.opaque_identity 1.; Sys.opaque_identity 2.|])
+
+let[@inline never] do_alloc_unknown_array_literal x =
+ Sys.opaque_identity [|x|]
+let alloc_unknown_array_literal () =
+ ignore (Sys.opaque_identity (do_alloc_unknown_array_literal 1.))
+
+let alloc_small_array () =
+ ignore (Sys.opaque_identity (Array.make 10 (Sys.opaque_identity 1)))
+
+let alloc_large_array () =
+ ignore (Sys.opaque_identity (Array.make 100000 (Sys.opaque_identity 1)))
+
+let alloc_closure () =
+ let x = Sys.opaque_identity 1 in
+ ignore (Sys.opaque_identity (fun () -> x))
+
+let floatarray = [| 1.; 2. |]
+let[@inline never] get0 a = a.(0)
+let getfloatfield () =
+ ignore (Sys.opaque_identity (get0 floatarray))
+
+let marshalled =
+ Marshal.to_string [Sys.opaque_identity 1] []
+let alloc_unmarshal () =
+ ignore (Sys.opaque_identity
+ ((Marshal.from_string [@inlined never]) (Sys.opaque_identity marshalled) 0))
+
+let alloc_ref () =
+ ignore (Sys.opaque_identity (ref (Sys.opaque_identity 1)))
+
+let fl = 1.
+let[@inline never] prod_floats a b = a *. b
+let alloc_boxedfloat () =
+ ignore (Sys.opaque_identity (prod_floats fl fl))
+
+let allocators =
+ [alloc_list_literal; alloc_pair; alloc_record; alloc_some;
+ alloc_array_literal; alloc_float_array_literal; alloc_unknown_array_literal;
+ alloc_small_array; alloc_large_array; alloc_closure;
+ getfloatfield; alloc_unmarshal; alloc_ref; alloc_boxedfloat]
+
+let test alloc =
+ Printf.printf "-----------\n%!";
+ let callstack = ref None in
+ start ~callstack_size:10 ~sampling_rate:1.
+ { null_tracker with
+ alloc_minor = (fun info ->
+ callstack := Some info.callstack;
+ None
+ );
+ alloc_major = (fun info ->
+ callstack := Some info.callstack;
+ None
+ );
+ };
+ alloc ();
+ stop ();
+ match !callstack with
+ | None -> Printf.printf "No callstack\n%!";
+ | Some cs -> Printexc.print_raw_backtrace stdout cs
+
+let () =
+ List.iter test allocators
--- /dev/null
+-----------
+Raised by primitive operation at Callstacks.alloc_list_literal in file "callstacks.ml", line 19, characters 30-53
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_pair in file "callstacks.ml", line 22, characters 30-76
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_record in file "callstacks.ml", line 27, characters 12-66
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_some in file "callstacks.ml", line 30, characters 30-60
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_array_literal in file "callstacks.ml", line 33, characters 30-55
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_float_array_literal in file "callstacks.ml", line 37, characters 12-62
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.do_alloc_unknown_array_literal in file "callstacks.ml", line 40, characters 22-27
+Called from Callstacks.alloc_unknown_array_literal in file "callstacks.ml", line 42, characters 30-65
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_small_array in file "callstacks.ml", line 45, characters 30-69
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_large_array in file "callstacks.ml", line 48, characters 30-73
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_closure.(fun) in file "callstacks.ml", line 52, characters 30-43
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+No callstack
+-----------
+Raised by primitive operation at Stdlib__marshal.from_bytes in file "marshal.ml", line 61, characters 9-35
+Called from Callstacks.alloc_unmarshal in file "callstacks.ml", line 63, characters 12-87
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.alloc_ref in file "callstacks.ml", line 66, characters 30-59
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
+-----------
+Raised by primitive operation at Callstacks.prod_floats in file "callstacks.ml", line 69, characters 37-43
+Called from Callstacks.alloc_boxedfloat in file "callstacks.ml", line 71, characters 30-49
+Called from Callstacks.test in file "callstacks.ml", line 93, characters 2-10
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Callstacks in file "callstacks.ml", line 100, characters 2-27
--- /dev/null
+2: 0.42 false
+Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 2-19
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+3: 0.42 false
+Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 6-18
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+4: 0.42 true
+Raised by primitive operation at Comballoc.f4 in file "comballoc.ml", line 12, characters 11-20
+Called from Comballoc.f in file "comballoc.ml", line 15, characters 13-17
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+2: 0.01 false
+Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 2-19
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+3: 0.01 false
+Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 6-18
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+4: 0.01 true
+Raised by primitive operation at Comballoc.f4 in file "comballoc.ml", line 12, characters 11-20
+Called from Comballoc.f in file "comballoc.ml", line 15, characters 13-17
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+2: 0.83 false
+Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 2-19
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+3: 0.83 false
+Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 6-18
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+4: 0.83 true
+Raised by primitive operation at Comballoc.f4 in file "comballoc.ml", line 12, characters 11-20
+Called from Comballoc.f in file "comballoc.ml", line 15, characters 13-17
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+OK
--- /dev/null
+(* TEST
+ flags = "-g"
+ * bytecode
+ reference = "${test_source_directory}/comballoc.byte.reference"
+ * native
+ reference = "${test_source_directory}/comballoc.opt.reference"
+ compare_programs = "false"
+*)
+
+open Gc.Memprof
+
+let f4 n = (n,n,n,n)
+
+let[@inline never] f n =
+ (n, (n, n, f4 n))
+
+let test sampling_rate =
+ let allocs = Array.make 257 0 in
+ let deallocs = Array.make 257 0 in
+ let promotes = Array.make 257 0 in
+ let callstacks = Array.make 257 None in
+ start ~callstack_size:10 ~sampling_rate
+ { null_tracker with
+ alloc_minor = (fun info ->
+ allocs.(info.size) <- allocs.(info.size) + info.n_samples;
+ begin match callstacks.(info.size) with
+ | None -> callstacks.(info.size) <- Some info.callstack
+ | Some s -> assert (s = info.callstack)
+ end;
+ Some (info.size, info.n_samples));
+ dealloc_minor = (fun (sz,n) ->
+ deallocs.(sz) <- deallocs.(sz) + n);
+ promote = (fun (sz,n) ->
+ promotes.(sz) <- promotes.(sz) + n;
+ None);
+ };
+ let iter = 100_000 in
+ let arr = Array.make iter (0,0,0,0) in
+ for i = 0 to Array.length arr - 1 do
+ let (_, (_, _, x)) = Sys.opaque_identity f i in
+ arr.(i) <- x;
+ done;
+ Gc.minor ();
+ stop ();
+ ignore (Sys.opaque_identity arr);
+ for i = 0 to 256 do
+ assert (deallocs.(i) + promotes.(i) = allocs.(i));
+ if allocs.(i) > 0 then begin
+ let total = (i + 1) * iter in
+ (* allocs.(i) / total is
+ Binomial(total, rate) / total
+ which is approx.
+ Normal(total * rate, total * rate*(1-rate)) / total
+ which is
+ Normal(1, rate*(1-rate) / total)
+ which has stddev sqrt(rate*(1-rate)/total)
+ which is less than 10^-3 for the values here.
+ So, an error of 0.005 (enough to make %.2f print differently)
+ is a 5-sigma event, with probability less than 3*10^-7 *)
+ Printf.printf "%d: %.2f %b\n" i
+ (float_of_int allocs.(i) /. float_of_int total)
+ (promotes.(i) > 1000);
+ (match callstacks.(i) with
+ | Some s -> Printexc.print_raw_backtrace stdout s
+ | None -> assert false)
+ end
+ done
+
+let () =
+ List.iter test [0.42; 0.01; 0.83]
+
+
+let no_callback_after_stop trigger =
+ let stopped = ref false in
+ let cnt = ref 0 in
+ start ~callstack_size:0 ~sampling_rate:1.
+ { null_tracker with
+ alloc_minor = (fun info ->
+ assert(not !stopped);
+ incr cnt;
+ if !cnt > trigger then begin
+ stop ();
+ stopped := true
+ end;
+ None);
+ };
+ for i = 0 to 1000 do ignore (Sys.opaque_identity f i) done;
+ assert !stopped
+
+let () =
+ for i = 0 to 1000 do no_callback_after_stop i done;
+ Printf.printf "OK\n"
--- /dev/null
+2: 0.42 false
+Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 2-19
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+3: 0.42 false
+Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 6-18
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+4: 0.42 true
+Raised by primitive operation at Comballoc.f4 in file "comballoc.ml" (inlined), line 12, characters 11-20
+Called from Comballoc.f in file "comballoc.ml", line 15, characters 13-17
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+2: 0.01 false
+Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 2-19
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+3: 0.01 false
+Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 6-18
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+4: 0.01 true
+Raised by primitive operation at Comballoc.f4 in file "comballoc.ml" (inlined), line 12, characters 11-20
+Called from Comballoc.f in file "comballoc.ml", line 15, characters 13-17
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+2: 0.83 false
+Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 2-19
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+3: 0.83 false
+Raised by primitive operation at Comballoc.f in file "comballoc.ml", line 15, characters 6-18
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+4: 0.83 true
+Raised by primitive operation at Comballoc.f4 in file "comballoc.ml" (inlined), line 12, characters 11-20
+Called from Comballoc.f in file "comballoc.ml", line 15, characters 13-17
+Called from Comballoc.test in file "comballoc.ml", line 40, characters 25-48
+Called from Stdlib__list.iter in file "list.ml", line 110, characters 12-15
+Called from Comballoc in file "comballoc.ml", line 70, characters 2-35
+OK
--- /dev/null
+(* TEST
+ exit_status = "2"
+*)
+
+open Gc.Memprof
+
+let alloc_tracker on_alloc =
+ { null_tracker with
+ alloc_minor = (fun info -> on_alloc info; None);
+ alloc_major = (fun info -> on_alloc info; None);
+ }
+
+(* We don't want to print the backtrace. We just want to make sure the
+ exception is printed.
+ This also makes sure [Printexc] is loaded, otherwise we don't use
+ its uncaught exception handler. *)
+let _ = Printexc.record_backtrace false
+
+let _ =
+ start ~callstack_size:10 ~sampling_rate:1.
+ (alloc_tracker (fun _ -> failwith "callback failed"));
+ ignore (Sys.opaque_identity (Array.make 200 0));
+ stop ()
--- /dev/null
+Fatal error: exception Failure("callback failed")
--- /dev/null
+(* TEST
+ exit_status = "2"
+*)
+
+open Gc.Memprof
+
+(* We don't want to print the backtrace. We just want to make sure the
+ exception is printed.
+ This also makes sure [Printexc] is loaded, otherwise we don't use
+ its uncaught exception handler. *)
+let _ = Printexc.record_backtrace false
+
+let _ =
+ start ~callstack_size:10 ~sampling_rate:1.
+ { null_tracker with
+ alloc_minor = (fun _ -> assert false);
+ alloc_major = (fun _ -> assert false);
+ };
+ ignore (Sys.opaque_identity (ref (ref 42)));
+ stop ()
--- /dev/null
+Fatal error: exception File "exception_callback_minor.ml", line 16, characters 30-36: Assertion failed
--- /dev/null
+(* TEST
+ flags = "-g"
+ * bytecode
+ * native
+ compare_programs = "false"
+*)
+
+open Gc.Memprof
+
+let alloc_tracker on_alloc =
+ { null_tracker with
+ alloc_minor = (fun info -> on_alloc info; None);
+ alloc_major = (fun info -> on_alloc info; None);
+ }
+
+type t = I of int | II of int * int | Cons of t
+let rec t_of_len = function
+ | len when len <= 1 -> assert false
+ | 2 -> I 1
+ | 3 -> II (2, 3)
+ | len -> Cons (t_of_len (len - 2))
+
+let marshalled_data = Hashtbl.create 17
+let[@inline never] get_marshalled_data len : t =
+ Marshal.from_string (Hashtbl.find marshalled_data len) 0
+let precompute_marshalled_data lo hi =
+ for len = lo to hi do
+ if not (Hashtbl.mem marshalled_data len) then
+ Hashtbl.add marshalled_data len (Marshal.to_string (t_of_len len) [])
+ done
+
+let root = ref []
+let[@inline never] do_intern lo hi cnt keep =
+ for j = 0 to cnt-1 do
+ for i = lo to hi do
+ root := get_marshalled_data i :: !root
+ done;
+ if not keep then root := []
+ done
+
+let check_nosample () =
+ Printf.printf "check_nosample\n%!";
+ precompute_marshalled_data 2 3000;
+ let fail_on_alloc _ =
+ Printf.printf "Callback called with sampling_rate = 0\n";
+ assert(false)
+ in
+ start ~callstack_size:10 ~sampling_rate:0. (alloc_tracker fail_on_alloc);
+ do_intern 2 3000 1 false;
+ stop ()
+
+let () = check_nosample ()
+
+let check_counts_full_major force_promote =
+ Printf.printf "check_counts_full_major\n%!";
+ precompute_marshalled_data 2 3000;
+ let nalloc_minor = ref 0 in
+ let nalloc_major = ref 0 in
+ let enable = ref true in
+ let npromote = ref 0 in
+ let ndealloc_minor = ref 0 in
+ let ndealloc_major = ref 0 in
+ start ~callstack_size:10 ~sampling_rate:0.01
+ {
+ alloc_minor = (fun _ ->
+ if not !enable then None
+ else Some (incr nalloc_minor)
+ );
+ alloc_major = (fun _ ->
+ if not !enable then None
+ else Some (incr nalloc_major)
+ );
+ promote = (fun _ ->
+ Some (incr npromote)
+ );
+ dealloc_minor = (fun _ ->
+ incr ndealloc_minor
+ );
+ dealloc_major = (fun _ ->
+ incr ndealloc_major
+ );
+ };
+ do_intern 2 3000 1 true;
+ enable := false;
+ assert (!ndealloc_minor = 0 && !ndealloc_major = 0);
+ if force_promote then begin
+ Gc.full_major ();
+ assert (!ndealloc_minor = 0 && !ndealloc_major = 0 &&
+ !npromote = !nalloc_minor);
+ root := [];
+ Gc.full_major ();
+ assert (!ndealloc_minor = 0 &&
+ !ndealloc_major = !nalloc_minor + !nalloc_major);
+ end else begin
+ root := [];
+ Gc.minor ();
+ Gc.full_major ();
+ Gc.full_major ();
+ assert (!nalloc_minor = !ndealloc_minor + !npromote &&
+ !ndealloc_major = !npromote + !nalloc_major)
+ end;
+ stop ()
+
+let () =
+ check_counts_full_major false;
+ check_counts_full_major true
+
+let check_no_nested () =
+ Printf.printf "check_no_nested\n%!";
+ precompute_marshalled_data 2 300;
+ let in_callback = ref false in
+ let cb _ =
+ assert (not !in_callback);
+ in_callback := true;
+ do_intern 100 200 1 false;
+ in_callback := false;
+ ()
+ in
+ let cb' _ = cb (); Some () in
+ start ~callstack_size:10 ~sampling_rate:1.
+ {
+ alloc_minor = cb';
+ alloc_major = cb';
+ promote = cb';
+ dealloc_minor = cb;
+ dealloc_major = cb;
+ };
+ do_intern 100 200 1 false;
+ stop ()
+
+let () = check_no_nested ()
+
+let check_distrib lo hi cnt rate =
+ Printf.printf "check_distrib %d %d %d %f\n%!" lo hi cnt rate;
+ precompute_marshalled_data lo hi;
+ let smp = ref 0 in
+ let alloc info =
+ (* We also allocate the list constructor in the minor heap,
+ so we filter that out. *)
+ if info.unmarshalled then begin
+ assert (info.size = 1 || info.size = 2);
+ assert (info.n_samples > 0);
+ smp := !smp + info.n_samples
+ end;
+ in
+ start ~callstack_size:10 ~sampling_rate:rate (alloc_tracker alloc);
+ do_intern lo hi cnt false;
+ stop ();
+
+ (* The probability distribution of the number of samples follows a
+ binomial distribution of parameters tot_alloc and rate. Given
+ that tot_alloc*rate and tot_alloc*(1-rate) are large (i.e., >
+ 100), this distribution is approximately equal to a normal
+ distribution. We compute a 1e-8 confidence interval for !smp
+ using quantiles of the normal distribution, and check that we are
+ in this confidence interval. *)
+ let tot_alloc = cnt*(lo+hi)*(hi-lo+1)/2 in
+ assert (float tot_alloc *. rate > 100. &&
+ float tot_alloc *. (1. -. rate) > 100.);
+ let mean = float tot_alloc *. rate in
+ let stddev = sqrt (float tot_alloc *. rate *. (1. -. rate)) in
+ (* This assertion has probability to fail close to 1e-8. *)
+ assert (abs_float (mean -. float !smp) <= stddev *. 5.7)
+
+let () =
+ check_distrib 2 3000 3 0.00001;
+ check_distrib 2 3000 1 0.0001;
+ check_distrib 2 2000 1 0.01;
+ check_distrib 2 2000 1 0.9;
+ check_distrib 300000 300000 20 0.1
+
+let () =
+ Printf.printf "OK !\n"
--- /dev/null
+check_nosample
+check_counts_full_major
+check_counts_full_major
+check_no_nested
+check_distrib 2 3000 3 0.000010
+check_distrib 2 3000 1 0.000100
+check_distrib 2 2000 1 0.010000
+check_distrib 2 2000 1 0.900000
+check_distrib 300000 300000 20 0.100000
+OK !
--- /dev/null
+(* TEST
+ flags = "-g"
+ * bytecode
+ * native
+ compare_programs = "false"
+*)
+
+open Gc.Memprof
+
+let rec allocate_list accu = function
+ | 0 -> accu
+ | n -> allocate_list (n::accu) (n-1)
+
+let[@inline never] allocate_lists len cnt =
+ for j = 0 to cnt-1 do
+ ignore (allocate_list [] len)
+ done
+
+let check_distrib len cnt rate =
+ Printf.printf "check_distrib %d %d %f\n%!" len cnt rate;
+ let smp = ref 0 in
+ start ~callstack_size:10 ~sampling_rate:rate
+ { null_tracker with
+ alloc_major = (fun _ -> assert false);
+ alloc_minor = (fun info ->
+ assert (info.size = 2);
+ assert (info.n_samples > 0);
+ assert (not info.unmarshalled);
+ smp := !smp + info.n_samples;
+ None);
+ };
+ allocate_lists len cnt;
+ stop ();
+
+ (* The probability distribution of the number of samples follows a
+ binomial distribution of parameters tot_alloc and rate. Given
+ that tot_alloc*rate and tot_alloc*(1-rate) are large (i.e., >
+ 100), this distribution is approximately equal to a normal
+ distribution. We compute a 1e-8 confidence interval for !smp
+ using quantiles of the normal distribution, and check that we are
+ in this confidence interval. *)
+ let tot_alloc = cnt*len*3 in
+ assert (float tot_alloc *. rate > 100. &&
+ float tot_alloc *. (1. -. rate) > 100.);
+ let mean = float tot_alloc *. rate in
+ let stddev = sqrt (float tot_alloc *. rate *. (1. -. rate)) in
+ (* This assertion has probability to fail close to 1e-8. *)
+ assert (abs_float (mean -. float !smp) <= stddev *. 5.7)
+
+let () =
+ check_distrib 10 1000000 0.01;
+ check_distrib 1000000 10 0.00001;
+ check_distrib 1000000 10 0.0001;
+ check_distrib 1000000 10 0.001;
+ check_distrib 1000000 10 0.01;
+ check_distrib 100000 10 0.1;
+ check_distrib 100000 10 0.9
+
+let () =
+ Printf.printf "OK !\n"
--- /dev/null
+check_distrib 10 1000000 0.010000
+check_distrib 1000000 10 0.000010
+check_distrib 1000000 10 0.000100
+check_distrib 1000000 10 0.001000
+check_distrib 1000000 10 0.010000
+check_distrib 100000 10 0.100000
+check_distrib 100000 10 0.900000
+OK !
--- /dev/null
+(* TEST
+ modules = "minor_no_postpone_stub.c"
+*)
+
+open Gc.Memprof
+
+let notify_minor ref_ok ref_done =
+ { null_tracker with
+ alloc_minor = (fun _ ->
+ assert !ref_ok;
+ ref_done := true;
+ None);
+ }
+
+let () =
+ let callback_ok = ref true in
+ let callback_done = ref false in
+ start ~callstack_size:0 ~sampling_rate:1.
+ (notify_minor callback_ok callback_done);
+ ignore (Sys.opaque_identity (ref 0));
+ assert(!callback_done);
+ callback_ok := false;
+ stop ()
+
+external alloc_stub : unit -> unit ref = "alloc_stub"
+
+let () =
+ let callback_ok = ref false in
+ let callback_done = ref false in
+ start ~callstack_size:0 ~sampling_rate:1.
+ (notify_minor callback_ok callback_done);
+ ignore (Sys.opaque_identity (alloc_stub ()));
+ assert(not !callback_done);
+ callback_ok := true;
+ stop ();
+ assert(!callback_done)
--- /dev/null
+#include "caml/alloc.h"
+
+value alloc_stub(value v) {
+ return caml_alloc(1, 0);
+}
--- /dev/null
+(* TEST
+modules = "thread_exit_in_callback_stub.c"
+exit_status = "42"
+* hassysthreads
+include systhreads
+** bytecode
+** native
+*)
+
+(* We cannot tell Ocamltest that this program is supposed to stop with
+ a fatal error. Instead, we install a fatal error hook and call exit(42) *)
+external install_fatal_error_hook : unit -> unit = "install_fatal_error_hook"
+
+let _ =
+ install_fatal_error_hook ();
+ Gc.Memprof.(start ~callstack_size:10 ~sampling_rate:1.
+ { null_tracker with alloc_minor = fun _ -> Thread.exit (); None });
+ ignore (Sys.opaque_identity (ref 1))
--- /dev/null
+Fatal error hook: Thread.exit called from a memprof callback.
--- /dev/null
+#include <stdio.h>
+#include "caml/misc.h"
+#include "caml/mlvalues.h"
+
+void fatal_error_hook_exit_3 (char *msg, va_list args) {
+ fprintf(stderr, "Fatal error hook: ");
+ vfprintf(stderr, msg, args);
+ fprintf(stderr, "\n");
+ exit(42);
+}
+
+
+value install_fatal_error_hook (value unit) {
+ caml_fatal_error_hook = fatal_error_hook_exit_3;
+ return Val_unit;
+}
| 'c' { f1 "\u{1F42B}" }
| 'd' { f1 {|}|} }
| 'e' { (* " *) } (* " *) }
+ | 'f' { (* {%foo bar| *) } (* |bar} *) }
let () =
let f' = ignore in
f' '"'
+
+(* test {|*)|}, {%foo|*)|} and {%%f.oo bar|*)|bar} *)
+(* test {%foo {%| *)
+
+let () = ignore {foo||foo}
%}
%token <string> Tident
--- /dev/null
+File "tool-ocamlc-open-error.ml", line 1:
+Warning 24: bad source file name: "Tool-ocamlc-open-error" is not a valid module name.
+File "command line argument: -open "F("", line 1, characters 1-2:
+Error: Syntax error
--- /dev/null
+(* TEST
+* setup-ocamlc.byte-build-env
+** ocamlc.byte
+flags = "-open F("
+ocamlc_byte_exit_status = "2"
+*** check-ocamlc.byte-output
+*)
<arg>
Nolabel
expression (stop_after_parsing_impl.ml[12,306+13]..[12,306+19])
- Pexp_constant PConst_string("true",None)
+ Pexp_constant PConst_string("true",(stop_after_parsing_impl.ml[12,306+14]..[12,306+18]),None)
]
<arg>
Nolabel
--- /dev/null
+wrong argument 'scheduling'; option '-stop-after' expects one of: parsing typing.
--- /dev/null
+(* TEST
+* setup-ocamlc.byte-build-env
+compiler_output = "compiler-output.raw"
+** ocamlc.byte
+ flags = "-stop-after scheduling"
+ ocamlc_byte_exit_status = "2"
+*** script
+ script = "sh ${test_source_directory}/stop_after_scheduling.sh"
+ output = "compiler-output"
+**** check-ocamlc.byte-output
+compiler_output = "compiler-output"
+*)
+
+(* this file is just a test driver, the test does not contain real OCaml code *)
--- /dev/null
+#!/bin/sh
+
+grep "wrong argument 'scheduling'" compiler-output.raw | grep "stop-after" | sed 's/^.*: wrong argument/wrong argument/'
# will not necessarily be ran by GNU make
# The same holds for $< and $@
+.NOTPARALLEL:
+
SOURCES = A.ml B.ml C.ml D.ml
OBJECTS = lib.cmo $(SOURCES:%.ml=Lib%.cmo)
NOBJECTS = $(OBJECTS:%.cmo=%.cmx)
# will not necessarily be ran by GNU make
# The same holds for $< and $@
+.NOTPARALLEL:
+
SOURCES = A.ml B.ml C.ml
OBJECTS = $(SOURCES:%.ml=Lib%.cmo)
NOBJECTS = $(OBJECTS:%.cmo=%.cmx)
--- /dev/null
+(* TEST
+ * native-compiler
+ ** setup-ocamlopt.byte-build-env
+ *** ocamlopt.byte
+ flags = "-stop-after scheduling -S"
+ ocamlopt_byte_exit_status = "0"
+ **** check-ocamlopt.byte-output
+ ***** script
+ script = "sh ${test_source_directory}/stop_after_scheduling.sh"
+*)
+
+(* this file is just a test driver, the test does not contain real OCaml code *)
--- /dev/null
+#!/bin/sh
+
+set -e
+
+asm=stop_after_scheduling.${asmext}
+obj=stop_after_scheduling.${objext}
+cmx=stop_after_scheduling.cmx
+
+# Check that cmx is generated but asm and obj are not
+if [ -e "$asm" ] ; then
+ echo "unexpected $asm found" > ${ocamltest_response}
+ test_result=${TEST_FAIL}
+else if [ -e "$obj" ] ; then
+ echo "unexpected $obj found" > ${ocamltest_response}
+ test_result=${TEST_FAIL}
+ else if [ -e "$cmx" ] ; then
+ test_result=${TEST_PASS}
+ else
+ echo "not found expected $cmx" > ${ocamltest_response}
+ test_result=${TEST_FAIL}
+ fi
+ fi
+fi
+exit ${test_result}
--- /dev/null
+(* TEST
+ * expect
+*)
+
+(* This is a known-bug file for use of 'rec' by the '#show' command,
+ to record known regressions from #7453 and #9094 *)
+
+type t = T of t;;
+[%%expect{|
+type t = T of t
+|}]
+#show t;;
+(* this output is INCORRECT, it should not use nonrec *)
+[%%expect{|
+type nonrec t = T of t
+|}];;
+
+type nonrec s = Foo of t;;
+[%%expect{|
+type nonrec s = Foo of t
+|}];;
+#show s;;
+(* this output is CORRECT, it uses nonrec *)
+[%%expect{|
+type nonrec s = Foo of t
+|}];;
+
+
+
+module M : sig type t val x : t end = struct type t = int let x = 0 end;;
+[%%expect{|
+module M : sig type t val x : t end
+|}];;
+(* this output is CORRECT, it does not use 'rec' *)
+[%%expect{|
+|}];;
+
+module rec M : sig type t val x : M.t end = struct type t = int let x = 0 end;;
+(* this output is strange, it is surprising to use M/2 here. *)
+[%%expect{|
+module rec M : sig type t val x : M/2.t end
+|}];;
+#show_module M;;
+(* this output is INCORRECT, it should use 'rec' *)
+[%%expect{|
+module M : sig type t val x : M.t end
+|}];;
--- /dev/null
+let answer = 42
--- /dev/null
+(* TEST
+ files = "mod.ml"
+ * expect
+*)
+
+#mod_use "mod.ml"
+[%%expect {|
+module Mod : sig val answer : int end
+|}];;
Warning 21: this statement never returns (or has an unsound type.)
val g : unit -> int = <fun>
Exception: Not_found.
-Raised at file "//toplevel//", line 2, characters 17-26
-Called from file "//toplevel//", line 1, characters 11-15
-Called from file "toplevel/toploop.ml", line 212, characters 17-27
+Raised at f in file "//toplevel//", line 2, characters 11-26
+Called from g in file "//toplevel//", line 1, characters 11-15
+Called from Toploop.load_lambda in file "toplevel/toploop.ml", line 212, characters 17-27
--- /dev/null
+(* TEST
+ * expect
+*)
+
+(* this is a set of tests to test the #show functionality
+ * of toplevel *)
+
+#show Foo;;
+[%%expect {|
+Unknown element.
+|}];;
+
+module type S = sig type t val x : t end;;
+module M : S = struct type t = int let x = 3 end;;
+
+[%%expect {|
+module type S = sig type t val x : t end
+module M : S
+|}];;
+
+#show M;;
+[%%expect {|
+module M : S
+|}];;
+
+#show S;;
+[%%expect {|
+module type S = sig type t val x : t end
+|}];;
+
+#show Invalid_argument;;
+[%%expect {|
+exception Invalid_argument of string
+|}];;
+
+#show Some;;
+[%%expect {|
+type 'a option = None | Some of 'a
+|}];;
+
+#show option;;
+[%%expect {|
+type nonrec 'a option = None | Some of 'a
+|}];;
+
+#show Open_binary;;
+[%%expect {|
+type Stdlib.open_flag =
+ Open_rdonly
+ | Open_wronly
+ | Open_append
+ | Open_creat
+ | Open_trunc
+ | Open_excl
+ | Open_binary
+ | Open_text
+ | Open_nonblock
+|}];;
+
+#show open_flag;;
+[%%expect {|
+type nonrec open_flag =
+ Open_rdonly
+ | Open_wronly
+ | Open_append
+ | Open_creat
+ | Open_trunc
+ | Open_excl
+ | Open_binary
+ | Open_text
+ | Open_nonblock
+|}];;
+
+type extensible = ..;;
+type extensible += A | B of int;;
+[%%expect {|
+type extensible = ..
+type extensible += A | B of int
+|}];;
+
+#show A;;
+[%%expect {|
+type extensible += A
+|}];;
+
+#show B;;
+[%%expect {|
+type extensible += B of int
+|}];;
+
+#show extensible;;
+[%%expect {|
+type nonrec extensible = ..
+|}];;
+
+type 'a t = ..;;
+type _ t += A : int t;;
+[%%expect{|
+type 'a t = ..
+type _ t += A : int t
+|}];;
+
+#show A;;
+[%%expect{|
+type 'a t += A : int t
+|}];;
--- /dev/null
+(* TEST
+ flags = " -short-paths "
+ * expect
+*)
+
+(* This is currently just a regression test for the bug
+ reported here: https://github.com/ocaml/ocaml/issues/9828 *)
+
+#show list;;
+[%%expect {|
+type nonrec 'a list = [] | (::) of 'a * 'a list
+|}];;
+
+type 'a t;;
+#show t;;
+[%%expect {|
+type 'a t
+type nonrec 'a t
+|}];;
--- /dev/null
+(* TEST
+ * expect
+*)
+
+(* Test a success case *)
+#use_output {|echo let x = 42|}
+[%%expect {|
+val x : int = 42
+|}];;
+
+(* When the command fails *)
+#use_output {|false|}
+[%%expect {|
+Command exited with code 1.
+|}];;
+
+(* When the code is invalid *)
+#use_output {|echo 1 :: x|}
+[%%expect {|
+File "(command-output)", line 1, characters 5-6:
+1 | 1 :: x
+ ^
+Error: This expression has type int but an expression was expected of type
+ int list
+|}];;
(setglobal Comparison_table!
(let
(gen_cmp = (function x y : int (caml_compare x y))
- int_cmp = (function x[int] y[int] : int (caml_int_compare x y))
- bool_cmp = (function x y : int (caml_int_compare x y))
- intlike_cmp = (function x y : int (caml_int_compare x y))
- float_cmp = (function x[float] y[float] : int (caml_float_compare x y))
+ int_cmp = (function x[int] y[int] : int (compare_ints x y))
+ bool_cmp = (function x y : int (compare_ints x y))
+ intlike_cmp = (function x y : int (compare_ints x y))
+ float_cmp = (function x[float] y[float] : int (compare_floats x y))
string_cmp = (function x y : int (caml_string_compare x y))
- int32_cmp = (function x[int32] y[int32] : int (caml_int32_compare x y))
- int64_cmp = (function x[int64] y[int64] : int (caml_int64_compare x y))
+ int32_cmp = (function x[int32] y[int32] : int (compare_bints int32 x y))
+ int64_cmp = (function x[int64] y[int64] : int (compare_bints int64 x y))
nativeint_cmp =
(function x[nativeint] y[nativeint] : int
- (caml_nativeint_compare x y))
+ (compare_bints nativeint x y))
gen_eq = (function x y (caml_equal x y))
int_eq = (function x[int] y[int] (== x y))
bool_eq = (function x y (== x y))
int64_ge = (function x[int64] y[int64] (Int64.>= x y))
nativeint_ge = (function x[nativeint] y[nativeint] (Nativeint.>= x y))
eta_gen_cmp = (function prim prim stub (caml_compare prim prim))
- eta_int_cmp = (function prim prim stub (caml_int_compare prim prim))
- eta_bool_cmp = (function prim prim stub (caml_int_compare prim prim))
- eta_intlike_cmp = (function prim prim stub (caml_int_compare prim prim))
- eta_float_cmp = (function prim prim stub (caml_float_compare prim prim))
+ eta_int_cmp = (function prim prim stub (compare_ints prim prim))
+ eta_bool_cmp = (function prim prim stub (compare_ints prim prim))
+ eta_intlike_cmp = (function prim prim stub (compare_ints prim prim))
+ eta_float_cmp = (function prim prim stub (compare_floats prim prim))
eta_string_cmp =
(function prim prim stub (caml_string_compare prim prim))
- eta_int32_cmp = (function prim prim stub (caml_int32_compare prim prim))
- eta_int64_cmp = (function prim prim stub (caml_int64_compare prim prim))
+ eta_int32_cmp =
+ (function prim prim stub (compare_bints int32 prim prim))
+ eta_int64_cmp =
+ (function prim prim stub (compare_bints int64 prim prim))
eta_nativeint_cmp =
- (function prim prim stub (caml_nativeint_compare prim prim))
+ (function prim prim stub (compare_bints nativeint prim prim))
eta_gen_eq = (function prim prim stub (caml_equal prim prim))
eta_int_eq = (function prim prim stub (== prim prim))
eta_bool_eq = (function prim prim stub (== prim prim))
(setglobal Module_coercion!
- (let (M = (module-defn(M) module_coercion.ml(15):436-1135 (makeblock 0)))
+ (let
+ (M =
+ (module-defn(M) Module_coercion module_coercion.ml(15):436-1135
+ (makeblock 0)))
(makeblock 0 M
- (module-defn(M_int) module_coercion.ml(46):1552-1591
+ (module-defn(M_int) Module_coercion module_coercion.ml(46):1552-1591
(makeblock 0 (function prim stub (array.length[int] prim))
(function prim prim stub (array.get[int] prim prim))
(function prim prim stub (array.unsafe_get[int] prim prim))
(function prim prim prim stub (array.set[int] prim prim prim))
(function prim prim prim stub
(array.unsafe_set[int] prim prim prim))
- (function prim prim stub (caml_int_compare prim prim))
+ (function prim prim stub (compare_ints prim prim))
(function prim prim stub (== prim prim))
(function prim prim stub (!= prim prim))
(function prim prim stub (< prim prim))
(function prim prim stub (> prim prim))
(function prim prim stub (<= prim prim))
(function prim prim stub (>= prim prim))))
- (module-defn(M_float) module_coercion.ml(47):1594-1637
+ (module-defn(M_float) Module_coercion module_coercion.ml(47):1594-1637
(makeblock 0 (function prim stub (array.length[float] prim))
(function prim prim stub (array.get[float] prim prim))
(function prim prim stub (array.unsafe_get[float] prim prim))
(function prim prim prim stub (array.set[float] prim prim prim))
(function prim prim prim stub
(array.unsafe_set[float] prim prim prim))
- (function prim prim stub (caml_float_compare prim prim))
+ (function prim prim stub (compare_floats prim prim))
(function prim prim stub (==. prim prim))
(function prim prim stub (!=. prim prim))
(function prim prim stub (<. prim prim))
(function prim prim stub (>. prim prim))
(function prim prim stub (<=. prim prim))
(function prim prim stub (>=. prim prim))))
- (module-defn(M_string) module_coercion.ml(48):1640-1685
+ (module-defn(M_string) Module_coercion module_coercion.ml(48):1640-1685
(makeblock 0 (function prim stub (array.length[addr] prim))
(function prim prim stub (array.get[addr] prim prim))
(function prim prim stub (array.unsafe_get[addr] prim prim))
(function prim prim stub (caml_string_greaterthan prim prim))
(function prim prim stub (caml_string_lessequal prim prim))
(function prim prim stub (caml_string_greaterequal prim prim))))
- (module-defn(M_int32) module_coercion.ml(49):1688-1731
+ (module-defn(M_int32) Module_coercion module_coercion.ml(49):1688-1731
(makeblock 0 (function prim stub (array.length[addr] prim))
(function prim prim stub (array.get[addr] prim prim))
(function prim prim stub (array.unsafe_get[addr] prim prim))
(function prim prim prim stub (array.set[addr] prim prim prim))
(function prim prim prim stub
(array.unsafe_set[addr] prim prim prim))
- (function prim prim stub (caml_int32_compare prim prim))
+ (function prim prim stub (compare_bints int32 prim prim))
(function prim prim stub (Int32.== prim prim))
(function prim prim stub (Int32.!= prim prim))
(function prim prim stub (Int32.< prim prim))
(function prim prim stub (Int32.> prim prim))
(function prim prim stub (Int32.<= prim prim))
(function prim prim stub (Int32.>= prim prim))))
- (module-defn(M_int64) module_coercion.ml(50):1734-1777
+ (module-defn(M_int64) Module_coercion module_coercion.ml(50):1734-1777
(makeblock 0 (function prim stub (array.length[addr] prim))
(function prim prim stub (array.get[addr] prim prim))
(function prim prim stub (array.unsafe_get[addr] prim prim))
(function prim prim prim stub (array.set[addr] prim prim prim))
(function prim prim prim stub
(array.unsafe_set[addr] prim prim prim))
- (function prim prim stub (caml_int64_compare prim prim))
+ (function prim prim stub (compare_bints int64 prim prim))
(function prim prim stub (Int64.== prim prim))
(function prim prim stub (Int64.!= prim prim))
(function prim prim stub (Int64.< prim prim))
(function prim prim stub (Int64.> prim prim))
(function prim prim stub (Int64.<= prim prim))
(function prim prim stub (Int64.>= prim prim))))
- (module-defn(M_nativeint) module_coercion.ml(51):1780-1831
+ (module-defn(M_nativeint) Module_coercion module_coercion.ml(51):1780-1831
(makeblock 0 (function prim stub (array.length[addr] prim))
(function prim prim stub (array.get[addr] prim prim))
(function prim prim stub (array.unsafe_get[addr] prim prim))
(function prim prim prim stub (array.set[addr] prim prim prim))
(function prim prim prim stub
(array.unsafe_set[addr] prim prim prim))
- (function prim prim stub (caml_nativeint_compare prim prim))
+ (function prim prim stub (compare_bints nativeint prim prim))
(function prim prim stub (Nativeint.== prim prim))
(function prim prim stub (Nativeint.!= prim prim))
(function prim prim stub (Nativeint.< prim prim))
(setglobal Module_coercion!
- (let (M = (module-defn(M) module_coercion.ml(15):436-1135 (makeblock 0)))
+ (let
+ (M =
+ (module-defn(M) Module_coercion module_coercion.ml(15):436-1135
+ (makeblock 0)))
(makeblock 0 M
- (module-defn(M_int) module_coercion.ml(46):1552-1591
+ (module-defn(M_int) Module_coercion module_coercion.ml(46):1552-1591
(makeblock 0 (function prim stub (array.length[int] prim))
(function prim prim stub (array.get[int] prim prim))
(function prim prim stub (array.unsafe_get[int] prim prim))
(function prim prim prim stub (array.set[int] prim prim prim))
(function prim prim prim stub
(array.unsafe_set[int] prim prim prim))
- (function prim prim stub (caml_int_compare prim prim))
+ (function prim prim stub (compare_ints prim prim))
(function prim prim stub (== prim prim))
(function prim prim stub (!= prim prim))
(function prim prim stub (< prim prim))
(function prim prim stub (> prim prim))
(function prim prim stub (<= prim prim))
(function prim prim stub (>= prim prim))))
- (module-defn(M_float) module_coercion.ml(47):1594-1637
+ (module-defn(M_float) Module_coercion module_coercion.ml(47):1594-1637
(makeblock 0 (function prim stub (array.length[addr] prim))
(function prim prim stub (array.get[addr] prim prim))
(function prim prim stub (array.unsafe_get[addr] prim prim))
(function prim prim prim stub (array.set[addr] prim prim prim))
(function prim prim prim stub
(array.unsafe_set[addr] prim prim prim))
- (function prim prim stub (caml_float_compare prim prim))
+ (function prim prim stub (compare_floats prim prim))
(function prim prim stub (==. prim prim))
(function prim prim stub (!=. prim prim))
(function prim prim stub (<. prim prim))
(function prim prim stub (>. prim prim))
(function prim prim stub (<=. prim prim))
(function prim prim stub (>=. prim prim))))
- (module-defn(M_string) module_coercion.ml(48):1640-1685
+ (module-defn(M_string) Module_coercion module_coercion.ml(48):1640-1685
(makeblock 0 (function prim stub (array.length[addr] prim))
(function prim prim stub (array.get[addr] prim prim))
(function prim prim stub (array.unsafe_get[addr] prim prim))
(function prim prim stub (caml_string_greaterthan prim prim))
(function prim prim stub (caml_string_lessequal prim prim))
(function prim prim stub (caml_string_greaterequal prim prim))))
- (module-defn(M_int32) module_coercion.ml(49):1688-1731
+ (module-defn(M_int32) Module_coercion module_coercion.ml(49):1688-1731
(makeblock 0 (function prim stub (array.length[addr] prim))
(function prim prim stub (array.get[addr] prim prim))
(function prim prim stub (array.unsafe_get[addr] prim prim))
(function prim prim prim stub (array.set[addr] prim prim prim))
(function prim prim prim stub
(array.unsafe_set[addr] prim prim prim))
- (function prim prim stub (caml_int32_compare prim prim))
+ (function prim prim stub (compare_bints int32 prim prim))
(function prim prim stub (Int32.== prim prim))
(function prim prim stub (Int32.!= prim prim))
(function prim prim stub (Int32.< prim prim))
(function prim prim stub (Int32.> prim prim))
(function prim prim stub (Int32.<= prim prim))
(function prim prim stub (Int32.>= prim prim))))
- (module-defn(M_int64) module_coercion.ml(50):1734-1777
+ (module-defn(M_int64) Module_coercion module_coercion.ml(50):1734-1777
(makeblock 0 (function prim stub (array.length[addr] prim))
(function prim prim stub (array.get[addr] prim prim))
(function prim prim stub (array.unsafe_get[addr] prim prim))
(function prim prim prim stub (array.set[addr] prim prim prim))
(function prim prim prim stub
(array.unsafe_set[addr] prim prim prim))
- (function prim prim stub (caml_int64_compare prim prim))
+ (function prim prim stub (compare_bints int64 prim prim))
(function prim prim stub (Int64.== prim prim))
(function prim prim stub (Int64.!= prim prim))
(function prim prim stub (Int64.< prim prim))
(function prim prim stub (Int64.> prim prim))
(function prim prim stub (Int64.<= prim prim))
(function prim prim stub (Int64.>= prim prim))))
- (module-defn(M_nativeint) module_coercion.ml(51):1780-1831
+ (module-defn(M_nativeint) Module_coercion module_coercion.ml(51):1780-1831
(makeblock 0 (function prim stub (array.length[addr] prim))
(function prim prim stub (array.get[addr] prim prim))
(function prim prim stub (array.unsafe_get[addr] prim prim))
(function prim prim prim stub (array.set[addr] prim prim prim))
(function prim prim prim stub
(array.unsafe_set[addr] prim prim prim))
- (function prim prim stub (caml_nativeint_compare prim prim))
+ (function prim prim stub (compare_bints nativeint prim prim))
(function prim prim stub (Nativeint.== prim prim))
(function prim prim stub (Nativeint.!= prim prim))
(function prim prim stub (Nativeint.< prim prim))
--- /dev/null
+(* TEST
+ * expect
+*)
+(** Test type-directed disambiguation and spellchecker hints *)
+
+type t = ..
+type t += Alpha | Aleph
+
+module M = struct
+ type w = ..
+ type w += Alpha | Beta ;;
+ type t += Beth
+end;;
+
+module F(X:sig end) = struct type u = .. type t += Gamma type u += Gamme end;;
+module X = struct end;;
+[%%expect {|
+type t = ..
+type t += Alpha | Aleph
+module M : sig type w = .. type w += Alpha | Beta type t += Beth end
+module F :
+ functor (X : sig end) ->
+ sig type u = .. type t += Gamma type u += Gamme end
+module X : sig end
+|}]
+
+let x: t = Alph;;
+[%%expect {|
+Line 1, characters 11-15:
+1 | let x: t = Alph;;
+ ^^^^
+Error: This variant expression is expected to have type t
+ The constructor Alph does not belong to type t
+Hint: Did you mean Aleph or Alpha?
+|}]
+
+open M;;
+let y : w = Alha;;
+[%%expect {|
+Line 2, characters 12-16:
+2 | let y : w = Alha;;
+ ^^^^
+Error: This variant expression is expected to have type M.w
+ The constructor Alha does not belong to type M.w
+Hint: Did you mean Alpha?
+|}]
+
+let z: t = Bet;;
+[%%expect {|
+Line 1, characters 11-14:
+1 | let z: t = Bet;;
+ ^^^
+Error: This variant expression is expected to have type t
+ The constructor Bet does not belong to type t
+Hint: Did you mean Beth?
+|}]
+
+
+module N = F(X);;
+open N
+let g = (Gamm:t);;
+[%%expect {|
+module N : sig type u = F(X).u = .. type t += Gamma type u += Gamme end
+Line 3, characters 9-13:
+3 | let g = (Gamm:t);;
+ ^^^^
+Error: This variant expression is expected to have type t
+ The constructor Gamm does not belong to type t
+Hint: Did you mean Gamma?
+|}];;
+
+raise Not_Found;;
+[%%expect {|
+Line 1, characters 6-15:
+1 | raise Not_Found;;
+ ^^^^^^^^^
+Error: This variant expression is expected to have type exn
+ The constructor Not_Found does not belong to type exn
+Hint: Did you mean Not_found?
+|}]
+
+(** Aliasing *)
+type r = ..;;
+module M = struct
+ type t = r = ..
+ type s = t = ..
+ module N = struct
+ type u = s = ..
+ type u += Foo
+ end
+end
+open M.N;;
+
+type exn += Foo;;
+
+let x : r = Foo;;
+[%%expect {|
+type r = ..
+module M :
+ sig
+ type t = r = ..
+ type s = t = ..
+ module N : sig type u = s = .. type u += Foo end
+ end
+type exn += Foo
+val x : r = M.N.Foo
+|}]
+
+(** Closed open extensible type support *)
+
+module M : sig
+ type t = private ..
+ type t += Aleph
+end = struct
+ type t = ..
+ type t += Aleph
+end;;
+open M;;
+
+type exn += Aleph ;;
+[%%expect {|
+module M : sig type t = private .. type t += Aleph end
+type exn += Aleph
+|}]
+
+let x : t = Aleph;;
+[%%expect {|
+val x : M.t = M.Aleph
+|}]
+
+module F(X: sig type t = .. end ) = struct type X.t+= Beth end
+module X = struct type t = .. end
+module FX = F(X) open FX
+type exn += Beth;;
+let x : X.t = Beth;;
+[%%expect {|
+module F : functor (X : sig type t = .. end) -> sig type X.t += Beth end
+module X : sig type t = .. end
+module FX : sig type X.t += Beth end
+type exn += Beth
+val x : X.t = <extension>
+|}]
+
+(** Aliasing *)
+
+type x = ..
+type x += Alpha
+module P = struct type p = x end
+
+let x: P.p = Alha;;
+[%%expect {|
+type x = ..
+type x += Alpha
+module P : sig type p = x end
+Line 7, characters 13-17:
+7 | let x: P.p = Alha;;
+ ^^^^
+Error: This variant expression is expected to have type P.p
+ The constructor Alha does not belong to type x
+Hint: Did you mean Alpha?
+|}]
+
+module M = struct type t = .. type t += T end
+module N = struct type s = M.t end
+let y: N.s = T ;;
+[%%expect {|
+module M : sig type t = .. type t += T end
+module N : sig type s = M.t end
+Line 3, characters 13-14:
+3 | let y: N.s = T ;;
+ ^
+Error: This variant expression is expected to have type N.s
+ The constructor T does not belong to type M.t
+|}]
+
+(** Pattern matching *)
+type x = ..
+type x += A | B
+type u = A | B
+module M = struct type y = .. type y+= A|B end
+open M
+let f: x -> int = function A -> 1 | B -> 2 | _ -> 0;;
+[%%expect {|
+type x = ..
+type x += A | B
+type u = A | B
+module M : sig type y = .. type y += A | B end
+val f : x -> int = <fun>
+|}]
+
+(** Local exception *)
+let x =
+ let exception Local in
+ raise Locl;;
+[%%expect {|
+Line 3, characters 8-12:
+3 | raise Locl;;
+ ^^^^
+Error: This variant expression is expected to have type exn
+ The constructor Locl does not belong to type exn
+Hint: Did you mean Local?
+|}]
+
+let x =
+ let exception Local in
+ let module M = struct type t = .. type t+= Local end in
+ let open M in
+ (Local:exn);;
+[%%expect{|
+val x : exn = Local
+|}
+]
+
+(** Path capture *)
+module M = struct type t = .. type t += T end
+open M
+let f = (=) M.T
+module M = struct type t = .. type t += S end
+open M
+let y = f T ;;
+[%%expect {|
+module M : sig type t = .. type t += T end
+val f : M.t -> bool = <fun>
+module M : sig type t = .. type t += S end
+val y : bool = true
+|}]
+
+(** Amniguity warning *)
+[@@@warning "+41"];;
+type a = Unique
+type t = ..
+type t += Unique
+module M = struct type s = .. type s+= Unique end open M
+type b = Unique
+let x = Unique;;
+[%%expect {|
+type a = Unique
+type t = ..
+type t += Unique
+module M : sig type s = .. type s += Unique end
+type b = Unique
+Line 7, characters 8-14:
+7 | let x = Unique;;
+ ^^^^^^
+Warning 41: Unique belongs to several types: b M.s t a
+The first one was selected. Please disambiguate if this is wrong.
+val x : b = Unique
+|}]
val y : exn * exn = (Foo (3, _), Bar (Some 5))
|}]
+module Empty = struct end
+module F(X:sig end) = struct
+ type t = ..
+ type t += A
+end
+let x = let open F(Empty) in (A:F(Empty).t) (* A is not printed *)
+[%%expect {|
+module Empty : sig end
+module F : functor (X : sig end) -> sig type t = .. type t += A end
+val x : F(Empty).t = <extension>
+|}]
+
+
(* Test Obj functions *)
type foo = ..
;;
[%%expect{|
-Line 3, characters 19-20:
-3 | | `Foo ( IntLit, 3
- ^
-Error: This pattern matches values of type int
- but a pattern was expected which matches values of type a = int
- This instance of int is ambiguous:
- it would escape the scope of its equation
+val simple_merged_annotated_under_poly_variant : 'a t * 'a -> unit = <fun>
|}]
let simple_merged_annotated_under_poly_variant_annotated (type a) pair =
--- /dev/null
+(* TEST
+ * expect
+*)
+
+type ('a, 'b) eq = Refl : ('a, 'a) eq
+type empty = (int, string) eq
+
+let f = function `Foo (_ : empty) -> .
+[%%expect{|
+type ('a, 'b) eq = Refl : ('a, 'a) eq
+type empty = (int, string) eq
+val f : [< `Foo of empty ] -> 'a = <fun>
+|}]
1 | ....f : type a b. (a,b) eq -> [< `A of a | `B] -> [< `A of b | `B] =
2 | fun Eq o -> o..............
Error: This definition has type
- ('a, 'b) eq -> ([< `A of 'b & 'a | `B ] as 'c) -> 'c
- which is less general than 'a0 'b0. ('a0, 'b0) eq -> 'c -> 'c
+ 'c. ('d, 'c) eq -> ([< `A of 'c & 'f & 'd | `B ] as 'e) -> 'e
+ which is less general than
+ 'a 'b. ('a, 'b) eq -> ([< `A of 'b & 'h | `B ] as 'g) -> 'g
|}];;
let f : type a b. (a,b) eq -> [`A of a | `B] -> [`A of b | `B] =
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
--- /dev/null
+(* TEST
+ * expect
+*)
+type foo = Foo;;
+[%%expect{|
+type foo = Foo
+|}];;
+
+(* this should fail with an error message,
+ not an uncaught exception (as it did temporarily
+ during the development of typedecl_separability) *)
+type bar = Bar : foo;;
+[%%expect{|
+Line 1, characters 17-20:
+1 | type bar = Bar : foo;;
+ ^^^
+Error: Constraints are not satisfied in this type.
+ Type foo should be an instance of bar
+|}];;
Line 1, characters 0-26:
1 | type 'a t = [`A of 'a t t];; (* fails *)
^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: In the definition of t, type 'a t t should be 'a t
+Error: This recursive type is not regular.
+ The type constructor t is defined as
+ type 'a t
+ but it is used as
+ 'a t t.
+ All uses need to match the definition for the recursive type to be regular.
|}];;
type 'a t = [`A of 'a t t] constraint 'a = 'a t;; (* fails since 4.04 *)
[%%expect{|
[%%expect{|
val f : t option -> int = <fun>
|}]
+
+type nothing = |
+type ('a, 'b, 'c) t = | A of 'a | B of 'b | C of 'c
+module Runner : sig
+ val ac : f:((unit, _, unit) t -> unit) -> unit
+end = struct
+ let ac ~f =
+ f (A ());
+ f (C ());
+ ;;
+end
+
+let f () =
+ Runner.ac
+ ~f:(fun (abc : (_,nothing,_) t) ->
+ let value =
+ match abc with
+ | A _ -> 1
+ in
+ Printf.printf "%i\n" value
+ )
+[%%expect{|
+type nothing = |
+type ('a, 'b, 'c) t = A of 'a | B of 'b | C of 'c
+module Runner : sig val ac : f:((unit, 'a, unit) t -> unit) -> unit end
+Lines 16-17, characters 8-18:
+16 | ........match abc with
+17 | | A _ -> 1
+Warning 8: this pattern-matching is not exhaustive.
+Here is an example of a case that is not matched:
+C ()
+val f : unit -> unit = <fun>
+|}]
+
+type nothing = |
+type 'b t = A | B of 'b | C
+let g (x:nothing t) = match x with A -> ()
+[%%expect{|
+type nothing = |
+type 'b t = A | B of 'b | C
+Line 3, characters 22-42:
+3 | let g (x:nothing t) = match x with A -> ()
+ ^^^^^^^^^^^^^^^^^^^^
+Warning 8: this pattern-matching is not exhaustive.
+Here is an example of a case that is not matched:
+C
+val g : nothing t -> unit = <fun>
+|}]
Error: This function should have type unit -> unit
but its first argument is labelled ?opt
|}];;
+
+
+(* More examples *)
+
+let f g = ignore (g ?x:(Some 2) ()); g ~x:3 () ;;
+[%%expect{|
+Line 1, characters 37-38:
+1 | let f g = ignore (g ?x:(Some 2) ()); g ~x:3 () ;;
+ ^
+Error: This function is applied to arguments
+ in an order different from other calls.
+ This is only allowed when the real type is known.
+|}];;
+
+let f g = let _ = g ?x:(Some 2) () in g ~x:3 () ;;
+[%%expect{|
+Line 1, characters 38-39:
+1 | let f g = let _ = g ?x:(Some 2) () in g ~x:3 () ;;
+ ^
+Error: This function is applied to arguments
+ in an order different from other calls.
+ This is only allowed when the real type is known.
+|}];;
+
+(* principality warning *)
+let f g = ignore (g : ?x:int -> unit -> int); g ~x:3 () ;;
+[%%expect{|
+val f : (?x:int -> unit -> int) -> int = <fun>
+|}, Principal{|
+Line 1, characters 51-52:
+1 | let f g = ignore (g : ?x:int -> unit -> int); g ~x:3 () ;;
+ ^
+Warning 18: using an optional argument here is not principal.
+val f : (?x:int -> unit -> int) -> int = <fun>
+|}];;
+
+let f g = ignore (g : ?x:int -> unit -> int); g ();;
+[%%expect{|
+val f : (?x:int -> unit -> int) -> int = <fun>
+|}, Principal{|
+Line 1, characters 46-47:
+1 | let f g = ignore (g : ?x:int -> unit -> int); g ();;
+ ^
+Warning 19: eliminated optional argument without principality.
+val f : (?x:int -> unit -> int) -> int = <fun>
+|}];;
+
+let f g = ignore (g : x:int -> unit -> int); g ();;
+[%%expect{|
+val f : (x:int -> unit -> int) -> x:int -> int = <fun>
+|}, Principal{|
+Line 1, characters 45-46:
+1 | let f g = ignore (g : x:int -> unit -> int); g ();;
+ ^
+Warning 19: commuted an argument without principality.
+val f : (x:int -> unit -> int) -> x:int -> int = <fun>
+|}];;
[ `A ]
The first variant type is private, it may not allow the tag(s) `A
|}]
+
+
+(** Check that the non-regularity error message is robust to permutation *)
+
+type ('a,'b,'c,'d,'e) a = [ `A of ('d,'a,'e,'c,'b) b ]
+and ('a,'b,'c,'d,'e) b = [ `B of ('c,'d,'e,'a,'b) c ]
+and ('a,'b,'c,'d,'e) c = [ `C of ('a,'b,'c,'d,'e) a ]
+[%%expect {|
+Line 3, characters 0-54:
+3 | type ('a,'b,'c,'d,'e) a = [ `A of ('d,'a,'e,'c,'b) b ]
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Error: This recursive type is not regular.
+ The type constructor a is defined as
+ type ('a, 'b, 'c, 'd, 'e) a
+ but it is used as
+ ('e, 'c, 'b, 'd, 'a) a
+ after the following expansion(s):
+ ('d, 'a, 'e, 'c, 'b) b = [ `B of ('e, 'c, 'b, 'd, 'a) c ],
+ ('e, 'c, 'b, 'd, 'a) c = [ `C of ('e, 'c, 'b, 'd, 'a) a ]
+ All uses need to match the definition for the recursive type to be regular.
+|}]
Type string is not compatible with type int
|}]
+(* PR#7696 *)
+let r = { (assert false) with contents = 1 } ;;
+[%%expect{|
+Line 1, characters 8-44:
+1 | let r = { (assert false) with contents = 1 } ;;
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Warning 23: all the fields are explicitly listed in this record:
+the 'with' clause is useless.
+Exception: Assert_failure ("", 1, 10).
+|}]
+
(* reexport *)
type ('a,'b) def = { x:int } constraint 'b = [> `A]
Error: The function applied to this argument has type
?x:'a -> a:'b -> ?y:'c -> z:'d -> unit
This argument cannot be applied with label ?y
+ Since OCaml 4.11, optional arguments do not commute when -nolabels is given
|}]
let f (g: ?x:_ -> _) = g ~y:None ?x:None; g ?x:None ()
^^^^
Error: The function applied to this argument has type ?x:'a -> 'b
This argument cannot be applied with label ~y
+ Since OCaml 4.11, optional arguments do not commute when -nolabels is given
|}]
+
+(** Show that optional arguments can be commuted, to some degree. *)
+
+let f i ?(a=0) ?(b=0) ?(c=0) ~x j =
+ i + a + b + c + x + j
+;;
+[%%expect{|
+val f : int -> ?a:int -> ?b:int -> ?c:int -> x:int -> int -> int = <fun>
+|}]
+;;
+
+(* [a], [b] and [c] can be commuted without issues *)
+
+f 3 ~c:2 ~a:1 ~b:0 ~x:4 5;;
+[%%expect{|
+Line 1, characters 7-8:
+1 | f 3 ~c:2 ~a:1 ~b:0 ~x:4 5;;
+ ^
+Error: The function applied to this argument has type
+ ?a:int -> ?b:int -> ?c:int -> x:int -> int -> int
+This argument cannot be applied with label ~c
+ Since OCaml 4.11, optional arguments do not commute when -nolabels is given
+|}]
+;;
+
+(* Now, for all of the following, the error appears on the first non optional
+ argument, but compare the reported function types: *)
+
+f 3 ~a:1 ~b:2 5 ~c:0 ~x:4;;
+[%%expect{|
+Line 1, characters 14-15:
+1 | f 3 ~a:1 ~b:2 5 ~c:0 ~x:4;;
+ ^
+Error: The function applied to this argument has type
+ ?c:int -> x:int -> int -> int
+This argument cannot be applied without label
+ Since OCaml 4.11, optional arguments do not commute when -nolabels is given
+|}]
+;;
+
+f 3 ~a:1 ~c:2 5 ~b:0 ~x:4;;
+[%%expect{|
+Line 1, characters 12-13:
+1 | f 3 ~a:1 ~c:2 5 ~b:0 ~x:4;;
+ ^
+Error: The function applied to this argument has type
+ ?b:int -> ?c:int -> x:int -> int -> int
+This argument cannot be applied with label ~c
+ Since OCaml 4.11, optional arguments do not commute when -nolabels is given
+|}]
+;;
+
+f 3 ~b:1 ~c:2 5 ~a:0 ~x:4;;
+[%%expect{|
+Line 1, characters 7-8:
+1 | f 3 ~b:1 ~c:2 5 ~a:0 ~x:4;;
+ ^
+Error: The function applied to this argument has type
+ ?a:int -> ?b:int -> ?c:int -> x:int -> int -> int
+This argument cannot be applied with label ~b
+ Since OCaml 4.11, optional arguments do not commute when -nolabels is given
+|}]
+;;
+
+(* Example given by Jacques when reviewing
+ https://github.com/ocaml/ocaml/pull/9411 *)
+
+let f ?x ?y () = ();;
+[%%expect{|
+val f : ?x:'a -> ?y:'b -> unit -> unit = <fun>
+|}]
+;;
+
+f ~y:3;;
+[%%expect{|
+Line 1, characters 5-6:
+1 | f ~y:3;;
+ ^
+Error: The function applied to this argument has type
+ ?x:'a -> ?y:'b -> unit -> unit
+This argument cannot be applied with label ~y
+ Since OCaml 4.11, optional arguments do not commute when -nolabels is given
+|}]
+;;
type 'a t = 'a Original.t = T
+
+let f: (module Original.T with type t = int) -> unit = fun _ -> ()
+let x = (module struct type t end: Original.T )
+let g: (module Original.T) -> unit = fun _ -> ()
type 'a t = T
+module type T = sig type t end
module = "middle.ml"
**** script
script = "rm -f original.cmi"
-***** ocamlc.byte
-module = "user.ml"
+***** expect
*)
+#directory "ocamlc.byte";;
+#load "middle.cmo"
+
let x:'a. 'a Middle.t =
let _r = ref 0 in
Middle.T
+[%%expect {|
+val x : 'a Middle.t = Middle.T
+|}]
+
+
+let () = Middle.(g x)
+[%%expect {|
+|}]
+
+let () = Middle.(f x)
+[%%expect {|
+Line 1, characters 19-20:
+1 | let () = Middle.(f x)
+ ^
+Error: This expression has type (module Original.T)
+ but an expression was expected of type
+ (module Original.T with type t = int)
+|}]
+
+let () = Middle.f (module struct end)
+[%%expect {|
+Line 1, characters 26-36:
+1 | let () = Middle.f (module struct end)
+ ^^^^^^^^^^
+Error: Signature mismatch:
+ Modules do not match: sig end is not included in Original.T
+|}]
--- /dev/null
+File "pr9695_bad.ml", line 10, characters 18-19:
+10 | let () = let open A in x
+ ^
+Error: This is an alias for module MissingModule, which is missing
--- /dev/null
+(* TEST
+flags = " -w a -no-alias-deps"
+ocamlc_byte_exit_status = "2"
+* setup-ocamlc.byte-build-env
+** ocamlc.byte
+*** check-ocamlc.byte-output
+*)
+
+module A = MissingModule
+let () = let open A in x
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
+ val filter_map : (elt -> elt option) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
+ val filter_map : (elt -> elt option) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
+ val filter_map : (elt -> elt option) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
+ val filter_map : (elt -> elt option) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
At position module type x = <here>
Illegal permutation of runtime components in a module type.
For example,
- the extension constructor "Three"
- and the value "one" are not in the same order
+ the exception "Three" and the value "one" are not in the same order
in the expected and actual module types.
|}]
At position module type x = <here>
Illegal permutation of runtime components in a module type.
For example,
- the extension constructor "B"
- and the extension constructor "A" are not in the same order
+ the exception "B" and the exception "A" are not in the same order
in the expected and actual module types.
|}]
--- /dev/null
+(* TEST
+ * expect *)
+
+(* #9623 *)
+
+module RhsScopeCheck = struct
+ module type Sig1 = sig
+ type t
+ type u = t
+ end
+
+ (* A scoping error here is intentional:
+ with-constraints "with <lhs> = <rhs>"
+ have their <rhs> evaluated in the current
+ typing environment, not within the signature
+ that they are constraining. [t] is unbound
+ in the current environment, so [with u = t]
+ must be rejected. *)
+ module type Check1 = Sig1
+ with type u = t
+end
+[%%expect{|
+Line 15, characters 18-19:
+15 | with type u = t
+ ^
+Error: Unbound type constructor t
+|}]
+
+
+module VarianceEnv = struct
+ module type Sig = sig
+ type +'a abstract
+ type +'a user = Foo of 'a abstract
+ end
+
+ module type Problem = sig
+ include Sig
+ module M : Sig
+ with type 'a abstract = 'a abstract
+ and type 'a user = 'a user
+
+ (* the variance annotation of [+'a foo] should be accepted, which
+ would not be the case if the with-constraint [and type 'a
+ user = 'a user] had its variance type-checked in the wrong typing
+ environment: see #9624 *)
+ type +'a foo = 'a M.user
+ end
+end
+[%%expect{|
+module VarianceEnv :
+ sig
+ module type Sig =
+ sig type +'a abstract type 'a user = Foo of 'a abstract end
+ module type Problem =
+ sig
+ type +'a abstract
+ type 'a user = Foo of 'a abstract
+ module M :
+ sig
+ type 'a abstract = 'a abstract
+ type 'a user = 'a user = Foo of 'a abstract
+ end
+ type 'a foo = 'a M.user
+ end
+ end
+|}]
+
+module UnboxedEnv = struct
+ module type Sig = sig
+ type 'a ind = 'a * int
+ type t = T : 'e ind -> t [@@unboxed]
+ end
+
+ module type Problem = sig
+ include Sig
+ module type ReboundSig = Sig
+ with type 'a ind = 'a ind
+ and type t = t
+ (* the with-definition [and type t = t] above should be accepted,
+ which would not be the case if its definition had separability
+ checked in the wrong typing environment: see #9624 *)
+ end
+end
+[%%expect{|
+module UnboxedEnv :
+ sig
+ module type Sig =
+ sig type 'a ind = 'a * int type t = T : 'e ind -> t [@@unboxed] end
+ module type Problem =
+ sig
+ type 'a ind = 'a * int
+ type t = T : 'e ind -> t [@@unboxed]
+ module type ReboundSig =
+ sig
+ type 'a ind = 'a ind
+ type t = t/2 = T : 'a ind -> t/1 [@@unboxed]
+ end
+ end
+ end
+|}]
+
+(* We can also have environment issues when unifying type parameters;
+ regression test contributed by Jacques Garrigue in #9623. *)
+module ParamsUnificationEnv = struct
+ module type Sig =
+ sig type 'a u = 'a list type +'a t constraint 'a = 'b u end
+ type +'a t = 'b constraint 'a = 'b list
+ module type Sig2 = Sig with type +'a t = 'a t
+end
+[%%expect{|
+module ParamsUnificationEnv :
+ sig
+ module type Sig =
+ sig type 'a u = 'a list type +'a t constraint 'a = 'b u end
+ type +'a t = 'b constraint 'a = 'b list
+ module type Sig2 =
+ sig type 'a u = 'a list type +'a t = 'a t constraint 'a = 'b u end
+ end
+|}]
+
+
+(* The construction of the "signature environment" was also broken
+ in earlier versions of the code. Regression test by Leo White in #9623. *)
+module CorrectEnvConstructionTest = struct
+ module type Sig = sig
+ type +'a user = Foo of 'a abstract
+ and +'a abstract
+ end
+
+ module type Problem = sig
+ include Sig
+ module M : Sig
+ with type 'a abstract = 'a abstract
+ and type 'a user = 'a user
+ type +'a foo = 'a M.user
+ end
+end
+[%%expect{|
+module CorrectEnvConstructionTest :
+ sig
+ module type Sig =
+ sig type 'a user = Foo of 'a abstract and +'a abstract end
+ module type Problem =
+ sig
+ type 'a user = Foo of 'a abstract
+ and +'a abstract
+ module M :
+ sig
+ type 'a user = 'a user = Foo of 'a abstract
+ and 'a abstract = 'a abstract
+ end
+ type 'a foo = 'a M.user
+ end
+ end
+|}]
+
+(* #9640 *)
+
+module type Packet_type = sig
+ type t
+end
+module type Unpacked_header = sig
+ module Packet_type : Packet_type
+ type t
+ val f : t -> Packet_type.t -> unit
+end
+module type Header = sig
+ module Packet_type : Packet_type
+ module Unpacked : Unpacked_header with module Packet_type := Packet_type
+end
+module type S = sig
+ module Packet_type : Packet_type
+ module Header : Header with module Packet_type = Packet_type
+end
+[%%expect{|
+module type Packet_type = sig type t end
+module type Unpacked_header =
+ sig
+ module Packet_type : Packet_type
+ type t
+ val f : t -> Packet_type.t -> unit
+ end
+module type Header =
+ sig
+ module Packet_type : Packet_type
+ module Unpacked : sig type t val f : t -> Packet_type.t -> unit end
+ end
+module type S =
+ sig
+ module Packet_type : Packet_type
+ module Header :
+ sig
+ module Packet_type : sig type t = Packet_type.t end
+ module Unpacked : sig type t val f : t -> Packet_type.t -> unit end
+ end
+ end
+|}]
+module type Iobuf_packet = sig
+ module Make (Header : Header) () :
+ S
+ with module Packet_type = Header.Packet_type
+ with module Header.Unpacked = Header.Unpacked
+end
+[%%expect{|
+module type Iobuf_packet =
+ sig
+ module Make :
+ functor (Header : Header) () ->
+ sig
+ module Packet_type : sig type t = Header.Packet_type.t end
+ module Header :
+ sig
+ module Packet_type : sig type t = Packet_type.t end
+ module Unpacked :
+ sig
+ type t = Header.Unpacked.t
+ val f : t -> Header.Packet_type.t -> unit
+ end
+ end
+ end
+ end
+|}]
+
+(* Simpler example by @gasche *)
+module type S = sig
+ type t
+ type u = t
+end
+module type Pack = sig
+ module M : S
+end
+[%%expect{|
+module type S = sig type t type u = t end
+module type Pack = sig module M : S end
+|}]
+module type Weird = sig
+ module M : S
+ module P : Pack
+ with type M.t = M.t
+ with type M.u = M.u
+end
+[%%expect{|
+module type Weird =
+ sig
+ module M : S
+ module P : sig module M : sig type t = M.t type u = M.u end end
+ end
+|}]
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
+ val filter_map : (elt -> elt option) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
end
module Asc : sig type t = int val compare : int -> int -> int end
module Desc : sig type t = int val compare : int -> int -> int end
-Line 15, characters 16-64:
+Line 15, characters 0-69:
15 | module rec M1 : S' with module Term0 := Asc and module T := Desc = M1;;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This variant or record definition does not match that of type M.t
Constructors do not match:
E of (MkT(M.T).t, MkT(M.T).t) eq
module rec M1 : S with type x = int and type y = bool = M1;;
[%%expect{|
-Line 1, characters 16-53:
+Line 1, characters 0-58:
1 | module rec M1 : S with type x = int and type y = bool = M1;;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This variant or record definition does not match that of type M1.t
Constructors do not match:
E of M1.x
let cast : type a b. (a,b) eq -> a -> b = fun Eq x -> x;;
cast eq 3;;
[%%expect{|
-Line 1, characters 16-53:
+Line 1, characters 0-58:
1 | module rec M1 : S with type x = int and type y = bool = M1;;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This variant or record definition does not match that of type M1.t
Constructors do not match:
E of (M1.x, M1.x) eq
--- /dev/null
+(* TEST
+ * expect
+*)
+
+module M : sig
+ type 'a t := [< `A ] as 'a
+ val f : 'a -> 'a t
+end = struct
+ let f x = x
+end;;
+[%%expect{|
+Line 2, characters 2-28:
+2 | type 'a t := [< `A ] as 'a
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^
+Error: Destructive substitutions are not supported for constrained
+ types (other than when replacing a type constructor with
+ a type constructor with the same arguments).
+|}]
+
+type foo = { foo : 'a. ([< `A] as 'a) -> 'a }
+
+module Foo (X : sig type 'a t := [< `A ] as 'a type foo2 = foo = { foo : 'a. 'a t -> 'a t } end) = struct
+ let f { X.foo } = foo
+end;;
+[%%expect{|
+type foo = { foo : 'a. ([< `A ] as 'a) -> 'a; }
+Line 3, characters 20-46:
+3 | module Foo (X : sig type 'a t := [< `A ] as 'a type foo2 = foo = { foo : 'a. 'a t -> 'a t } end) = struct
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^
+Error: Destructive substitutions are not supported for constrained
+ types (other than when replacing a type constructor with
+ a type constructor with the same arguments).
+|}]
+
+type bar = { bar : 'a. ([< `A] as 'a) -> 'a }
+
+module Bar (X : sig type 'a t := 'a type bar2 = bar = { bar : 'a. ([< `A] as 'a) t -> 'a t } end) = struct
+ let f { X.bar } = bar
+end;;
+[%%expect{|
+type bar = { bar : 'a. ([< `A ] as 'a) -> 'a; }
+module Bar :
+ functor
+ (X : sig type bar2 = bar = { bar : 'a. ([< `A ] as 'a) -> 'a; } end) ->
+ sig val f : X.bar2 -> ([< `A ] as 'a) -> 'a end
+|}]
--- /dev/null
+(* TEST
+ * expect
+*)
+
+module Test (S : sig module type S end) (M : S.S) =
+ struct open M (* should not succeed silently *) end
+[%%expect{|
+Line 2, characters 14-15:
+2 | struct open M (* should not succeed silently *) end
+ ^
+Error: This module is not a structure; it has type S.S
+|}]
module rec T : sig type t = T.t end = T;;
[%%expect{|
-Line 1, characters 15-35:
+Line 1, characters 0-39:
1 | module rec T : sig type t = T.t end = T;;
- ^^^^^^^^^^^^^^^^^^^^
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: The type abbreviation T.t is cyclic
|}]
|}];;
(* class ['a] c : unit -> object constraint 'a = int end
and ['a] d : unit -> object constraint 'a = int #c end *)
+(* Class type constraint *)
+module F(X:sig type t end) = struct
+ class type ['a] c = object
+ method m: 'a -> X.t
+ end
+end
+class ['a] c = object
+ constraint 'a = 'a #F(Int).c
+end
+[%%expect {|
+module F :
+ functor (X : sig type t end) ->
+ sig class type ['a] c = object method m : 'a -> X.t end end
+class ['a] c : object constraint 'a = < m : 'a -> Int.t; .. > end
+|}]
(* Self as parameter *)
class ['a] c (x : 'a) = object (self : 'b)
Line 1, characters 0-32:
1 | type 'a c = <f : 'a c; g : 'a d>
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: In the definition of d, type int c should be 'a c
+Error: This recursive type is not regular.
+ The type constructor c is defined as
+ type 'a c
+ but it is used as
+ int c
+ after the following expansion(s):
+ 'a d = < f : int c >
+ All uses need to match the definition for the recursive type to be regular.
|}];;
type 'a c = <f : 'a c; g : 'a d>
and 'a d = <f : 'a c>;;
Line 1, characters 0-24:
1 | type 'a u = < m : 'a v > and 'a v = 'a list u;;
^^^^^^^^^^^^^^^^^^^^^^^^
-Error: In the definition of v, type 'a list u should be 'a u
+Error: This recursive type is not regular.
+ The type constructor u is defined as
+ type 'a u
+ but it is used as
+ 'a list u
+ after the following expansion(s):
+ 'a v = 'a list u
+ All uses need to match the definition for the recursive type to be regular.
|}];;
(* PR#8198: Ctype.matches *)
val g : 'a -> int = <fun>
type 'a t = Leaf of 'a | Node of ('a * 'a) t
val depth : 'a t -> int = <fun>
-Line 6, characters 2-42:
-6 | function Leaf _ -> 1 | Node x -> 1 + d x
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: This definition has type 'a t -> int which is less general than
- 'a0. 'a0 t -> int
+val depth : 'a t -> int = <fun>
+val d : ('a * 'a) t -> int = <fun>
+Line 9, characters 2-46:
+9 | function Leaf x -> x | Node x -> 1 + depth x;; (* fails *)
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Error: This definition has type int t -> int which is less general than
+ 'a. 'a t -> int
|}];;
(* compare with records (should be the same) *)
Line 1, characters 0-28:
1 | type 'x t = < f : 'y. 'y t >;;
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: In the definition of t, type 'y t should be 'x t
+Error: This recursive type is not regular.
+ The type constructor t is defined as
+ type 'x t
+ but it is used as
+ 'y t.
+ All uses need to match the definition for the recursive type to be regular.
|}];;
(* PR#6056, PR#6057 *)
class d :
object method m : ?x:int -> unit -> int method n : int method n' : int end
|}]
+
+(* #1132 *)
+let rec foo : 'a . 'a -> 'd = fun x -> x
+[%%expect{|
+Line 1, characters 30-40:
+1 | let rec foo : 'a . 'a -> 'd = fun x -> x
+ ^^^^^^^^^^
+Error: This definition has type 'b -> 'b which is less general than
+ 'a. 'a -> 'c
+|}]
+
+(* #7741 *)
+type 'a s = S
+
+class type ['x] c = object
+ method x : 'x list
+end
+[%%expect{|
+type 'a s = S
+class type ['x] c = object method x : 'x list end
+|}]
+
+let x : 'a c = object
+ method x : 'b . 'b s list = [S]
+end
+[%%expect{|
+Lines 1-3, characters 15-3:
+1 | ...............object
+2 | method x : 'b . 'b s list = [S]
+3 | end
+Error: This expression has type < x : 'b. 'b s list >
+ but an expression was expected of type 'a c
+ The method x has type 'b. 'b s list, but the expected method type was
+ 'a list
+ The universal variable 'b would escape its scope
+|}]
+
+type u = < m : 'a. 'a s list * (< m : 'b. 'a s list * 'c > as 'c) >
+type v = < m : 'a. 'a s list * 'c > as 'c
+[%%expect{|
+type u = < m : 'a. 'a s list * (< m : 'a s list * 'b > as 'b) >
+type v = < m : 'a. 'a s list * 'b > as 'b
+|}]
+let f (x : u) = (x : v)
+[%%expect{|
+Line 1, characters 17-18:
+1 | let f (x : u) = (x : v)
+ ^
+Error: This expression has type u but an expression was expected of type v
+ The method m has type 'a s list * < m : 'b > as 'b,
+ but the expected method type was 'a. 'a s list * < m : 'a. 'b > as 'b
+ The universal variable 'a would escape its scope
+|}]
+
+type 'a s = private int
+[%%expect{|
+type 'a s = private int
+|}]
+let x : 'a c = object
+ method x : 'b . 'b s list = []
+end
+[%%expect{|
+Lines 1-3, characters 15-3:
+1 | ...............object
+2 | method x : 'b . 'b s list = []
+3 | end
+Error: This expression has type < x : 'b. 'b s list >
+ but an expression was expected of type 'a c
+ The method x has type 'b. 'b s list, but the expected method type was
+ 'a list
+ The universal variable 'b would escape its scope
+|}]
--- /dev/null
+(* TEST
+ * expect
+*)
+
+type 'p pair = 'a * 'b constraint 'p = < left:'a; right:'b>
+
+(* New in 4.11 *)
+let error: 'left 'right.
+ <left:'left; right:'right> pair -> <left:'right; right:'left> pair =
+ fun (x,y) -> (y,x)
+[%%expect{|
+type 'c pair = 'a * 'b constraint 'c = < left : 'a; right : 'b >
+val error :
+ < left : 'left; right : 'right > pair ->
+ < left : 'right; right : 'left > pair = <fun>
+|}]
+
+(* Known problem with polymorphic methods *)
+let foo :
+ < m : 'left 'right. <left:'left; right:'right> pair >
+ -> < m : 'left 'right. <left:'left; right:'right> pair >
+= fun x -> x
+
+[%%expect{|
+Line 4, characters 11-12:
+4 | = fun x -> x
+ ^
+Error: This expression has type
+ < m : 'left 'right. < left : 'left; right : 'right > pair >
+ but an expression was expected of type
+ < m : 'left 'right. < left : 'left; right : 'right > pair >
+ Type < left : 'left; right : 'right > pair = 'a * 'b
+ is not compatible with type < left : 'left0; right : 'right0 > pair
+ The method left has type 'a, but the expected method type was 'left
+ The universal variable 'left would escape its scope
+|}, Principal{|
+Line 4, characters 6-7:
+4 | = fun x -> x
+ ^
+Error: This pattern matches values of type
+ < m : 'left 'right. < left : 'left; right : 'right > pair >
+ but a pattern was expected which matches values of type
+ < m : 'left 'right. < left : 'left; right : 'right > pair >
+ Type < left : 'left; right : 'right > pair = 'a * 'b
+ is not compatible with type < left : 'left0; right : 'right0 > pair
+ The method left has type 'a, but the expected method type was 'left
+ The universal variable 'left would escape its scope
+|}]
--- /dev/null
+(* TEST
+ * expect
+*)
+
+let r = ref None
+
+module M : sig
+ val write : ([< `A of string | `B of int ] -> unit)
+end = struct
+ let write x =
+ match x with `A _ | `B _ -> r := Some x
+end
+[%%expect{|
+val r : '_weak1 option ref = {contents = None}
+Lines 5-8, characters 6-3:
+5 | ......struct
+6 | let write x =
+7 | match x with `A _ | `B _ -> r := Some x
+8 | end
+Error: Signature mismatch:
+ Modules do not match:
+ sig val write : _[< `A of '_weak2 | `B of '_weak3 ] -> unit end
+ is not included in
+ sig val write : [< `A of string | `B of int ] -> unit end
+ Values do not match:
+ val write : _[< `A of '_weak2 | `B of '_weak3 ] -> unit
+ is not included in
+ val write : [< `A of string | `B of int ] -> unit
+|}]
--- /dev/null
+(* TEST
+*)
+
+(* PR#9494 *)
+
+(* Additional test cases from Vincent Laviron: *)
+
+(* Looping version *)
+module rec M1 : sig
+ val f : unit -> unit
+ val g : unit -> unit
+end = struct
+ let f = M1.g
+ let g () = M1.f ()
+end
+
+(* Alias chain *)
+module rec M2 : sig
+ val f : unit -> unit
+ val g : unit -> unit
+end = struct
+ let f = M2.g
+ let g = M2.f
+end
+
+(* Original test case from the issue: *)
+
+module rec Id : sig
+ type t = {id : int}
+ val compare : t -> t -> int
+end = Id (* error here: undefined compare function *)
+
+module IdSet = Set.Make(Id)
+
+let _ = try
+ let basic_set = IdSet.singleton {id = 0} in
+ IdSet.mem {id = 1} basic_set (* diverge here *)
+with e -> print_endline @@ Printexc.to_string e; false
--- /dev/null
+File "pr9494.ml", line 31, characters 6-12: Undefined recursive module
-File "t01bad.ml", line 10, characters 15-35:
+File "t01bad.ml", line 10, characters 0-61:
10 | module rec A : sig type t = A.t end = struct type t = A.t end;;
- ^^^^^^^^^^^^^^^^^^^^
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: The type abbreviation A.t is cyclic
-File "t02bad.ml", line 10, characters 15-35:
+File "t02bad.ml", line 10, characters 0-61:
10 | module rec A : sig type t = B.t end = struct type t = B.t end
- ^^^^^^^^^^^^^^^^^^^^
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: The definition of A.t contains a cycle:
B.t
-File "t04bad.ml", line 10, characters 15-41:
+File "t04bad.ml", line 10, characters 0-73:
10 | module rec A : sig type t = int * A.t end = struct type t = int * A.t end;;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: The definition of A.t contains a cycle:
int * A.t
-File "t05bad.ml", line 10, characters 15-42:
+File "t05bad.ml", line 10, characters 0-75:
10 | module rec A : sig type t = B.t -> int end = struct type t = B.t -> int end
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: The definition of A.t contains a cycle:
B.t -> int
-File "t07bad.ml", line 10, characters 15-51:
+File "t07bad.ml", lines 10-11, characters 0-54:
10 | module rec A : sig type 'a t = <m: 'a list A.t> end
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: In the definition of A.t, type 'a list A.t should be 'a A.t
+11 | = struct type 'a t = <m: 'a list A.t> end..
+Error: This recursive type is not regular.
+ The type constructor A.t is defined as
+ type 'a A.t
+ but it is used as
+ 'a list A.t.
+ All uses need to match the definition for the recursive type to be regular.
-File "t08bad.ml", line 10, characters 15-68:
+File "t08bad.ml", lines 10-11, characters 0-71:
10 | module rec A : sig type 'a t = <m: 'a list B.t; n: 'a array B.t> end
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: In the definition of B.t, type 'a array A.t should be 'a A.t
+11 | = struct type 'a t = <m: 'a list B.t; n: 'a array B.t> end
+Error: This recursive type is not regular.
+ The type constructor A.t is defined as
+ type 'a A.t
+ but it is used as
+ 'a array A.t
+ after the following expansion(s):
+ 'a array B.t = 'a array A.t
+ All uses need to match the definition for the recursive type to be regular.
-File "t09bad.ml", line 10, characters 15-41:
+File "t09bad.ml", lines 10-11, characters 0-44:
10 | module rec A : sig type 'a t = 'a B.t end
- ^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: In the definition of B.t, type 'a array A.t should be 'a A.t
+11 | = struct type 'a t = 'a B.t end
+Error: This recursive type is not regular.
+ The type constructor A.t is defined as
+ type 'a A.t
+ but it is used as
+ 'a array A.t
+ after the following expansion(s):
+ 'a B.t = < m : 'a list A.t; n : 'a array A.t >
+ All uses need to match the definition for the recursive type to be regular.
-File "t11bad.ml", line 12, characters 15-52:
-12 | and B : sig type 'a t = <m: 'a array B.t> end
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: In the definition of B.t, type 'a array B.t should be 'a B.t
+File "t11bad.ml", lines 12-13, characters 7-55:
+12 | .......and B : sig type 'a t = <m: 'a array B.t> end
+13 | = struct type 'a t = <m: 'a array B.t> end..
+Error: This recursive type is not regular.
+ The type constructor B.t is defined as
+ type 'a B.t
+ but it is used as
+ 'a array B.t.
+ All uses need to match the definition for the recursive type to be regular.
-File "t12bad.ml", lines 11-15, characters 4-7:
-11 | ....sig
+File "t12bad.ml", lines 10-21, characters 0-7:
+10 | module rec M :
+11 | sig
12 | class ['a] c : 'a -> object
13 | method map : ('a -> 'b) -> 'b M.c
14 | end
-15 | end
-Error: In the definition of M.c, type 'b M.c should be 'a M.c
+...
+18 | method map : 'b. ('a -> 'b) -> 'b M.c
+19 | = fun f -> new M.c (f x)
+20 | end
+21 | end..
+Error: This recursive type is not regular.
+ The type constructor M.c is defined as
+ type 'a M.c
+ but it is used as
+ 'b M.c.
+ All uses need to match the definition for the recursive type to be regular.
-File "t14bad.ml", line 23, characters 17-39:
+File "t14bad.ml", line 23, characters 2-43:
23 | module rec U : T with type D.t = U'.t = U
- ^^^^^^^^^^^^^^^^^^^^^^
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: The definition of U.D.t contains a cycle:
U'.t
-File "t15bad.ml", line 11, characters 15-35:
+File "t15bad.ml", line 11, characters 0-61:
11 | module rec M : S' with type t = M.t = struct type t = M.t end;;
- ^^^^^^^^^^^^^^^^^^^^
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: The type abbreviation M.t is cyclic
--- /dev/null
+(* TEST
+ flags = " -short-paths "
+ * expect
+*)
+
+module M = struct type t = T end
+
+type t = M.t
+
+let x : M.t = S
+[%%expect {|
+module M : sig type t = T end
+type t = M.t
+Line 5, characters 14-15:
+5 | let x : M.t = S
+ ^
+Error: This variant expression is expected to have type t
+ The constructor S does not belong to type t
+|}]
+
+module M = struct
+ class c = object method foo = 3 end
+end
+
+type c = M.c
+
+let () = (new M.c)#bar
+[%%expect {|
+module M : sig class c : object method foo : int end end
+type c = M.c
+Line 7, characters 9-18:
+7 | let () = (new M.c)#bar
+ ^^^^^^^^^
+Error: This expression has type c
+ It has no method bar
+|}]
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
+ val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> key
val bindings : 'a t -> (key * 'a) list
^
Error: Unbound type constructor t
|}]
+
+type ('a, 'b) foo = Foo
+
+type 'a s = 'b list constraint 'a = (int, 'b) foo
+
+module type S = sig
+ type 'a t := 'a s * bool
+ type 'a bar = (int, 'a) foo
+ val x : string bar t
+end
+[%%expect{|
+type ('a, 'b) foo = Foo
+type 'a s = 'b list constraint 'a = (int, 'b) foo
+Line 6, characters 2-26:
+6 | type 'a t := 'a s * bool
+ ^^^^^^^^^^^^^^^^^^^^^^^^
+Error: Destructive substitutions are not supported for constrained
+ types (other than when replacing a type constructor with
+ a type constructor with the same arguments).
+|}]
|}]
-(* Valid substitutions in a recursive module may fail due to the ordering of
- the modules. *)
-
+(* Valid substitutions in a recursive module used to fail
+ due to the ordering of the modules. This is fixed since #9623. *)
module type S0 = sig
module rec M : sig type t = M2.t end
and M2 : sig type t = int end
end with type M.t = int
[%%expect {|
-Lines 1-4, characters 17-23:
-1 | .................sig
-2 | module rec M : sig type t = M2.t end
-3 | and M2 : sig type t = int end
-4 | end with type M.t = int
-Error: In this `with' constraint, the new definition of M.t
- does not match its original definition in the constrained signature:
- Type declarations do not match:
- type t = int
- is not included in
- type t = M2.t
+module type S0 =
+ sig module rec M : sig type t = int end and M2 : sig type t = int end end
|}]
1 | module M : Test_functor.S with type elt = unit = Test_functor.Apply (String)
^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: Signature mismatch:
- Modules do not match:
- sig
- type elt = String.t
- type t = Test_functor.Apply(String).t
- val create : elt -> t
- end
- is not included in
- sig type elt = unit type t val create : elt -> t end
+ ...
Type declarations do not match:
type elt = String.t
is not included in
1 | type t9 = K of { j : string; l : int } [@@ocaml.unboxed];;
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This type cannot be unboxed because
- its constructor has more than one argument.
+ its constructor has more than one field.
|}];;
(* let rec must be rejected *)
type 'a t [@@immediate]
type u = U : 'a t -> u [@@unboxed]
|}];;
+
+(* This could not be accepted without using a fixpoint to check unboxed declarations
+ (GPR#2188) *)
+type ('a, 'b) t = K : 'c -> (bool, 'c) t [@@unboxed]
+and t1 = T1 : (bool, int) t -> t1 [@@unboxed]
+[%%expect{|
+type ('a, 'b) t = K : 'c -> (bool, 'c) t [@@unboxed]
+and t1 = T1 : (bool, int) t -> t1 [@@unboxed]
+|}];;
+
+(* This real-world example of recursive declaration comes from Markus Mottl
+ -- see MPR#7361 *)
+type ('a, 'kind) tree =
+ | Root : { mutable value : 'a; mutable rank : int } -> ('a, [ `root ]) tree
+ | Inner : { mutable parent : 'a node } -> ('a, [ `inner ]) tree
+and 'a node = Node : ('a, _) tree -> 'a node [@@ocaml.unboxed]
+[%%expect{|
+type ('a, 'kind) tree =
+ Root : { mutable value : 'a; mutable rank : int;
+ } -> ('a, [ `root ]) tree
+ | Inner : { mutable parent : 'a node; } -> ('a, [ `inner ]) tree
+and 'a node = Node : ('a, 'b) tree -> 'a node [@@unboxed]
+|}];;
(* should fail *)
type 'a abs;;
-type t16 = A : _ abs -> t16 [@@ocaml.unboxed];;
+type t16 = A : 'a abs -> t16 [@@ocaml.unboxed];;
[%%expect{|
type 'a abs
-Line 2, characters 0-45:
-2 | type t16 = A : _ abs -> t16 [@@ocaml.unboxed];;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Line 2, characters 0-46:
+2 | type t16 = A : 'a abs -> t16 [@@ocaml.unboxed];;
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This type cannot be unboxed because
- it might contain both float and non-float values.
+ it might contain both float and non-float values,
+ depending on the instantiation of the existential variable 'a.
You should annotate it with [@@ocaml.boxed].
|}];;
1 | type t18 = A : _ list abs -> t18 [@@ocaml.unboxed];;
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This type cannot be unboxed because
- it might contain both float and non-float values.
+ it might contain both float and non-float values,
+ depending on the instantiation of an unnamed existential variable.
You should annotate it with [@@ocaml.boxed].
|}];;
(* regression test for PR#7511 (wrong determination of unboxability for GADTs)
*)
type 'a s = S : 'a -> 'a s [@@unboxed];;
-type t = T : _ s -> t [@@unboxed];;
+type t = T : 'a s -> t [@@unboxed];;
[%%expect{|
type 'a s = S : 'a -> 'a s [@@unboxed]
-Line 2, characters 0-33:
-2 | type t = T : _ s -> t [@@unboxed];;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Line 2, characters 0-34:
+2 | type t = T : 'a s -> t [@@unboxed];;
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This type cannot be unboxed because
- it might contain both float and non-float values.
+ it might contain both float and non-float values,
+ depending on the instantiation of the existential variable 'a.
You should annotate it with [@@ocaml.boxed].
|}];;
(* regression test for GPR#1133 (follow-up to PR#7511) *)
type 'a s = S : 'a -> 'a option s [@@unboxed];;
-type t = T : _ s -> t [@@unboxed];;
+type t = T : 'a s -> t [@@unboxed];;
[%%expect{|
type 'a s = S : 'a -> 'a option s [@@unboxed]
-Line 2, characters 0-33:
-2 | type t = T : _ s -> t [@@unboxed];;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Line 2, characters 0-34:
+2 | type t = T : 'a s -> t [@@unboxed];;
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This type cannot be unboxed because
- it might contain both float and non-float values.
+ it might contain both float and non-float values,
+ depending on the instantiation of the existential variable 'a.
You should annotate it with [@@ocaml.boxed].
|}];;
1 | type t = T : (unit -> _) M.r -> t [@@unboxed];;
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This type cannot be unboxed because
- it might contain both float and non-float values.
+ it might contain both float and non-float values,
+ depending on the instantiation of an unnamed existential variable.
You should annotate it with [@@ocaml.boxed].
|}];;
+(* accept *)
type 'a s = S : (unit -> 'a) M.r -> 'a option s [@@unboxed];;
[%%expect{|
type 'a s = S : (unit -> 'a) M.r -> 'a option s [@@unboxed]
|}];;
(* reject *)
-type t = T : _ s -> t [@@unboxed];;
+type t = T : 'a s -> t [@@unboxed];;
[%%expect{|
-Line 1, characters 0-33:
-1 | type t = T : _ s -> t [@@unboxed];;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Line 1, characters 0-34:
+1 | type t = T : 'a s -> t [@@unboxed];;
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This type cannot be unboxed because
- it might contain both float and non-float values.
+ it might contain both float and non-float values,
+ depending on the instantiation of the existential variable 'a.
You should annotate it with [@@ocaml.boxed].
|}];;
type 'a t = T : 'a s -> 'a t [@@unboxed]
|}];;
+(* Even without constraints, we need to mark abstract types as Deepsep:
+ unboxed GADTs can introduce equations that do not appear in the signature
+ (see GPR#2188) *)
+module N : sig
+ type 'a r
+ val inj : 'b -> (unit -> 'b) r
+end = struct
+ type _ r = K : 'b -> (unit -> 'b) r [@@unboxed]
+ let inj x = K x
+end;;
+[%%expect{|
+module N : sig type 'a r val inj : 'b -> (unit -> 'b) r end
+|}];;
+
+(* reject *)
+type t = T : (unit -> _) N.r -> t [@@unboxed];;
+[%%expect{|
+Line 1, characters 0-45:
+1 | type t = T : (unit -> _) N.r -> t [@@unboxed];;
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Error: This type cannot be unboxed because
+ it might contain both float and non-float values,
+ depending on the instantiation of an unnamed existential variable.
+ You should annotate it with [@@ocaml.boxed].
+|}];;
+
+(* accept *)
+type 'a s = S : (unit -> 'a) N.r -> 'a option s [@@unboxed];;
+[%%expect{|
+type 'a s = S : (unit -> 'a) N.r -> 'a option s [@@unboxed]
+|}];;
(* Another corner case from GPR#1133 *)
type _ s = S : 'a t -> _ s [@@unboxed]
and _ t = T : 'a -> 'a s t
;;
[%%expect{|
-Line 1, characters 0-39:
-1 | type _ s = S : 'a t -> _ s [@@unboxed]
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: This type cannot be unboxed because
- it might contain both float and non-float values.
- You should annotate it with [@@ocaml.boxed].
+type _ s = S : 'a t -> 'b s [@@unboxed]
+and _ t = T : 'a -> 'a s t
|}];;
(* regression test for PR#7511 (wrong determination of unboxability for GADTs)
*)
type 'a s = S : 'a -> 'a s [@@unboxed];;
-type t = T : _ s -> t [@@unboxed];;
+type t = T : 'a s -> t [@@unboxed];;
[%%expect{|
type 'a s = S : 'a -> 'a s [@@unboxed]
-Line 2, characters 0-33:
-2 | type t = T : _ s -> t [@@unboxed];;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Line 2, characters 0-34:
+2 | type t = T : 'a s -> t [@@unboxed];;
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This type cannot be unboxed because
- it might contain both float and non-float values.
+ it might contain both float and non-float values,
+ depending on the instantiation of the existential variable 'a.
You should annotate it with [@@ocaml.boxed].
|}];;
(* regression test for GPR#1133 (follow-up to PR#7511) *)
type 'a s = S : 'a -> 'a option s [@@unboxed];;
-type t = T : _ s -> t [@@unboxed];;
+type t = T : 'a s -> t [@@unboxed];;
[%%expect{|
type 'a s = S : 'a -> 'a option s [@@unboxed]
-Line 2, characters 0-33:
-2 | type t = T : _ s -> t [@@unboxed];;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Line 2, characters 0-34:
+2 | type t = T : 'a s -> t [@@unboxed];;
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This type cannot be unboxed because
- it might contain both float and non-float values.
+ it might contain both float and non-float values,
+ depending on the instantiation of the existential variable 'a.
You should annotate it with [@@ocaml.boxed].
|}];;
1 | type t = T : (unit -> _) M.r -> t [@@unboxed];;
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This type cannot be unboxed because
- it might contain both float and non-float values.
+ it might contain both float and non-float values,
+ depending on the instantiation of an unnamed existential variable.
You should annotate it with [@@ocaml.boxed].
|}];;
|}];;
(* reject *)
-type t = T : _ s -> t [@@unboxed];;
+type t = T : 'a s -> t [@@unboxed];;
[%%expect{|
-Line 1, characters 0-33:
-1 | type t = T : _ s -> t [@@unboxed];;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Line 1, characters 0-34:
+1 | type t = T : 'a s -> t [@@unboxed];;
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This type cannot be unboxed because
- it might contain both float and non-float values.
+ it might contain both float and non-float values,
+ depending on the instantiation of the existential variable 'a.
You should annotate it with [@@ocaml.boxed].
|}];;
and _ t = T : 'a -> 'a s t
;;
[%%expect{|
-Line 1, characters 0-39:
-1 | type _ s = S : 'a t -> _ s [@@unboxed]
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+type _ s = S : 'a t -> 'b s [@@unboxed]
+and _ t = T : 'a -> 'a s t
+|}];;
+
+(* GPR#2188: non-principality examples.
+ One of the two declarations [valid1] and [valid2] below will fail,
+ depending on the order in which GADT equality constraints
+ are processed by our implementation.
+ The previous unfolding implementation would accept both.
+
+ We decided to specify that, if two parameters are equal to each other,
+ then we would use the more constrained mode (Sep rather than Ind) for the
+ first/leftmost parameter, and Ind for the second one. With a left-to-right
+ reading of parameters, this corresponds to considering that the equality
+ is on the second parameter, equal to a parameter already seen, rather than
+ an equality on a not-yet-seen parameter.
+
+ In the example below, almost_eq will thus get the mode signature
+ (Sep, Ind) rather than (Ind, Sep).
+*)
+type (_, _) almost_eq = Almost_refl : 'a -> ('a, 'a) almost_eq [@@unboxed]
+[%%expect{|
+type (_, _) almost_eq = Almost_refl : 'a -> ('a, 'a) almost_eq [@@unboxed]
+|}];;
+
+
+type valid1 = Any : ('a, int) almost_eq -> valid1 [@@unboxed];;
+[%%expect{|
+Line 1, characters 0-61:
+1 | type valid1 = Any : ('a, int) almost_eq -> valid1 [@@unboxed];;
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Error: This type cannot be unboxed because
+ it might contain both float and non-float values,
+ depending on the instantiation of the existential variable 'a.
+ You should annotate it with [@@ocaml.boxed].
+|}];;
+type valid2 = Any : (int, 'a) almost_eq -> valid2 [@@unboxed];;
+[%%expect{|
+type valid2 = Any : (int, 'a) almost_eq -> valid2 [@@unboxed]
+|}];;
+
+(* rejected: equivalent to (exits 'a. 'a) *)
+type danger = Any : ('a, 'a) almost_eq -> danger [@@unboxed];;
+[%%expect{|
+Line 1, characters 0-60:
+1 | type danger = Any : ('a, 'a) almost_eq -> danger [@@unboxed];;
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This type cannot be unboxed because
- it might contain both float and non-float values.
+ it might contain both float and non-float values,
+ depending on the instantiation of the existential variable 'a.
You should annotate it with [@@ocaml.boxed].
|}];;
+
+
+(* GPR#2188: handling of cyclic types *)
+type 'a stream = unit -> [ `Cons of 'a * 'a stream ];;
+type safe = Any : 'a stream -> safe;;
+[%%expect{|
+type 'a stream = unit -> [ `Cons of 'a * 'a stream ]
+type safe = Any : 'a stream -> safe
+|}];;
+
+type 'a infinite_full_tree = unit -> [ `Node of 'a * ('a * 'a) stream ];;
+type safe_again = Any : 'a stream -> safe_again;;
+[%%expect{|
+type 'a infinite_full_tree = unit -> [ `Node of 'a * ('a * 'a) stream ]
+type safe_again = Any : 'a stream -> safe_again
+|}];;
+
+(** Note: there are no tests of rejected cyclic types, because
+ the type declarations that would be required to check these cases
+ (unproductive cycles in the type declaration) are already rejected by the
+ type-checker, before separability checking. See below *)
+type 'a id = Id of 'a [@@unboxed]
+type cycle = cycle id
+[%%expect{|
+type 'a id = Id of 'a [@@unboxed]
+Line 2, characters 0-21:
+2 | type cycle = cycle id
+ ^^^^^^^^^^^^^^^^^^^^^
+Error: The type abbreviation cycle is cyclic
+|}];;
type iub = I of int [@@unboxed]
external idub : iub -> iub = "%identity"
|}];;
+
+(* #9607: separability was not computed on with-constraints *)
+module type T = sig type 'k t end
+module M : T with type 'k t = string = struct
+ type 'k t = string
+end
+type t = T : 'k M.t -> t [@@unboxed]
+
+[%%expect{|
+module type T = sig type 'k t end
+module M : sig type 'k t = string end
+type t = T : 'k M.t -> t [@@unboxed]
+|}];;
+++ /dev/null
-external a : (int [@untagged]) -> unit = "a" "a_nat"
-external b : (int32 [@unboxed]) -> unit = "b" "b_nat"
-external c : (int64 [@unboxed]) -> unit = "c" "c_nat"
-external d : (nativeint [@unboxed]) -> unit = "d" "d_nat"
-external e : (float [@unboxed]) -> unit = "e" "e_nat"
-type t = private int
-external f : (t [@untagged]) -> unit = "f" "f_nat"
-module M :
- sig
- external a : int -> (int [@untagged]) = "a" "a_nat"
- external b : (int [@untagged]) -> int = "b" "b_nat"
- end
-Line 12, characters 2-71:
- external f : (int32 [@unboxed]) -> (int32 [@unboxed]) = "f" "noalloc"
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: The native code version of the primitive is mandatory when attributes [@untagged] or [@unboxed] are present
-Line 4, characters 2-61:
- external a : float -> float = "a" "noalloc" "a_nat" "float"
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Alert deprecated: [@@unboxed] + [@@noalloc] should be used instead of "float"
-Line 5, characters 2-53:
- external b : float -> float = "b" "noalloc" "b_nat"
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Alert deprecated: [@@noalloc] should be used instead of "noalloc"
-Line 6, characters 2-51:
- external c : float -> float = "c" "c_nat" "float"
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Alert deprecated: [@@unboxed] + [@@noalloc] should be used instead of "float"
-Line 7, characters 2-45:
- external d : float -> float = "d" "noalloc"
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Alert deprecated: [@@noalloc] should be used instead of "noalloc"
-Line 15, characters 6-70:
- ......struct
- external f : int -> (int [@untagged]) = "f" "f_nat"
- end..
-Error: Signature mismatch:
- Modules do not match:
- sig external f : int -> (int [@untagged]) = "f" "f_nat" end
- is not included in
- sig external f : int -> int = "f" "f_nat" end
- Values do not match:
- external f : int -> (int [@untagged]) = "f" "f_nat"
- is not included in
- external f : int -> int = "f" "f_nat"
-Line 4, characters 6-70:
- ......struct
- external f : (int [@untagged]) -> int = "f" "f_nat"
- end..
-Error: Signature mismatch:
- Modules do not match:
- sig external f : (int [@untagged]) -> int = "f" "f_nat" end
- is not included in
- sig external f : int -> int = "a" "a_nat" end
- Values do not match:
- external f : (int [@untagged]) -> int = "f" "f_nat"
- is not included in
- external f : int -> int = "a" "a_nat"
-Line 4, characters 6-73:
- ......struct
- external f : float -> (float [@unboxed]) = "f" "f_nat"
- end..
-Error: Signature mismatch:
- Modules do not match:
- sig external f : float -> (float [@unboxed]) = "f" "f_nat" end
- is not included in
- sig external f : float -> float = "f" "f_nat" end
- Values do not match:
- external f : float -> (float [@unboxed]) = "f" "f_nat"
- is not included in
- external f : float -> float = "f" "f_nat"
-Line 4, characters 6-73:
- ......struct
- external f : (float [@unboxed]) -> float = "f" "f_nat"
- end..
-Error: Signature mismatch:
- Modules do not match:
- sig external f : (float [@unboxed]) -> float = "f" "f_nat" end
- is not included in
- sig external f : float -> float = "a" "a_nat" end
- Values do not match:
- external f : (float [@unboxed]) -> float = "f" "f_nat"
- is not included in
- external f : float -> float = "a" "a_nat"
-Line 6, characters 6-56:
- ......struct
- external f : int -> int = "f" "f_nat"
- end..
-Error: Signature mismatch:
- Modules do not match:
- sig external f : int -> int = "f" "f_nat" end
- is not included in
- sig external f : int -> (int [@untagged]) = "f" "f_nat" end
- Values do not match:
- external f : int -> int = "f" "f_nat"
- is not included in
- external f : int -> (int [@untagged]) = "f" "f_nat"
-Line 4, characters 6-56:
- ......struct
- external f : int -> int = "a" "a_nat"
- end..
-Error: Signature mismatch:
- Modules do not match:
- sig external f : int -> int = "a" "a_nat" end
- is not included in
- sig external f : (int [@untagged]) -> int = "f" "f_nat" end
- Values do not match:
- external f : int -> int = "a" "a_nat"
- is not included in
- external f : (int [@untagged]) -> int = "f" "f_nat"
-Line 4, characters 6-60:
- ......struct
- external f : float -> float = "f" "f_nat"
- end..
-Error: Signature mismatch:
- Modules do not match:
- sig external f : float -> float = "f" "f_nat" end
- is not included in
- sig external f : float -> (float [@unboxed]) = "f" "f_nat" end
- Values do not match:
- external f : float -> float = "f" "f_nat"
- is not included in
- external f : float -> (float [@unboxed]) = "f" "f_nat"
-Line 4, characters 6-60:
- ......struct
- external f : float -> float = "a" "a_nat"
- end..
-Error: Signature mismatch:
- Modules do not match:
- sig external f : float -> float = "a" "a_nat" end
- is not included in
- sig external f : (float [@unboxed]) -> float = "f" "f_nat" end
- Values do not match:
- external f : float -> float = "a" "a_nat"
- is not included in
- external f : (float [@unboxed]) -> float = "f" "f_nat"
-Line 4, characters 14-19:
- external g : (float [@untagged]) -> float = "g" "g_nat";;
- ^^^^^
-Error: Don't know how to untag this type. Only int can be untagged
-Line 1, characters 14-17:
- external h : (int [@unboxed]) -> float = "h" "h_nat";;
- ^^^
-Error: Don't know how to unbox this type. Only float, int32, int64 and nativeint can be unboxed
-Line 3, characters 13-25:
- external i : int -> float [@unboxed] = "i" "i_nat";;
- ^^^^^^^^^^^^
-Error: Don't know how to unbox this type. Only float, int32, int64 and nativeint can be unboxed
-Line 3, characters 21-26:
- external j : int -> (float [@unboxed]) * float = "j" "j_nat";;
- ^^^^^
-Error: The attribute '@unboxed' should be attached to a direct argument or result of the primitive, it should not occur deeply into its type
-external k : int -> float = "k" "k_nat"
-Line 4, characters 0-61:
- external l : float -> float = "l" "l_nat" "float" [@@unboxed];;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: Cannot use "float" in conjunction with [@unboxed]/[@untagged]
-Line 1, characters 0-62:
- external m : (float [@unboxed]) -> float = "m" "m_nat" "float";;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: Cannot use "float" in conjunction with [@unboxed]/[@untagged]
-Line 1, characters 0-55:
- external n : float -> float = "n" "noalloc" [@@noalloc];;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: Cannot use "noalloc" in conjunction with [@@noalloc]
-Line 3, characters 0-45:
- external o : (float[@unboxed]) -> float = "o";;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: The native code version of the primitive is mandatory when attributes [@untagged] or [@unboxed] are present
-Line 1, characters 0-45:
- external p : float -> (float[@unboxed]) = "p";;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: The native code version of the primitive is mandatory when attributes [@untagged] or [@unboxed] are present
-Line 1, characters 0-44:
- external q : (int[@untagged]) -> float = "q";;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: The native code version of the primitive is mandatory when attributes [@untagged] or [@unboxed] are present
-Line 1, characters 0-42:
- external r : int -> (int[@untagged]) = "r";;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: The native code version of the primitive is mandatory when attributes [@untagged] or [@unboxed] are present
-Line 1, characters 0-42:
- external s : int -> int = "s" [@@untagged];;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: The native code version of the primitive is mandatory when attributes [@untagged] or [@unboxed] are present
-Line 1, characters 0-45:
- external t : float -> float = "t" [@@unboxed];;
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Error: The native code version of the primitive is mandatory when attributes [@untagged] or [@unboxed] are present
-type 'a b = B of 'a b b [@@unboxed]
-
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Warning 8: this pattern-matching is not exhaustive.
Here is an example of a case that is not matched:
-{left=Box 0; right=Box 0}
+({left=Box 0; right=Box 0}|{left=Box 1; right=Box _})
val f : int box pair -> unit = <fun>
|}]
--- /dev/null
+(* TEST
+ flags = " -w A "
+ * expect
+*)
+
+module type U = sig end
+[%%expect {|
+module type U = sig end
+|}]
+
+module M : sig
+ module F2 (_ : U) : U
+end = struct
+ module X = struct
+ let x = 13
+ end
+
+ module F1 (_ : U) = X
+ module F2 (M : U) = F1 (M)
+end
+[%%expect {|
+Line 5, characters 8-9:
+5 | let x = 13
+ ^
+Warning 32: unused value x.
+module M : sig module F2 : U -> U end
+|}]
+
+module N : sig
+ module F2 (_ : U) : U
+end = struct
+ module X = struct
+ let x = 13
+ end
+
+ module F1 (_ : U) = X
+ module F2 (_ : U) = F1 (struct end)
+end
+[%%expect {|
+Line 5, characters 8-9:
+5 | let x = 13
+ ^
+Warning 32: unused value x.
+module N : sig module F2 : U -> U end
+|}]
+
+
+module F (X : sig type t type s end) = struct type t = X.t end
+[%%expect {|
+Line 1, characters 25-31:
+1 | module F (X : sig type t type s end) = struct type t = X.t end
+ ^^^^^^
+Warning 34: unused type s.
+module F : functor (X : sig type t type s end) -> sig type t = X.t end
+|}]
let r = {x=true;z='z'}
end;; (* fail for missing label *)
[%%expect{|
+Line 3, characters 11-12:
+3 | let r = {x=true;z='z'}
+ ^
+Warning 42: this use of x relies on type-directed disambiguation,
+it will not compile with OCaml 4.00 or earlier.
Line 3, characters 10-24:
3 | let r = {x=true;z='z'}
^^^^^^^^^^^^^^
but a pattern was expected which matches values of type u
Types for tag `Key are incompatible
|}]
+
+(** no candidates after filtering;
+ This caused a temporary trunk regression identified by Florian Angeletti
+ while reviewing #9196
+ *)
+module M = struct
+ type t = { x:int; y:int}
+end
+type u = { a:int }
+let _ = ( { M.x=0 } : u );;
+[%%expect{|
+module M : sig type t = { x : int; y : int; } end
+type u = { a : int; }
+Line 5, characters 12-15:
+5 | let _ = ( { M.x=0 } : u );;
+ ^^^
+Error: The field M.x belongs to the record type M.t
+ but a field was expected belonging to the record type u
+|}]
--- /dev/null
+(* TEST
+ * expect
+*)
+
+[@@@ocaml.warning "+a"]
+
+module M : sig end = struct
+ module rec Foo : sig
+ type t
+ val create : Bar.t -> t
+ end = struct
+ type t = unit
+
+ let create _ = ()
+ end
+
+ and Bar : sig
+ type t
+ end = struct
+ type t = unit
+ end
+
+ let _ = Foo.create
+end;;
+[%%expect{|
+Line 14, characters 4-10:
+14 | type t
+ ^^^^^^
+Warning 34: unused type t.
+module M : sig end
+|}];;
echo "ld version is $LDVER, only 224 or above are supported";
test_result=${TEST_SKIP};
else
- test_reslut=${TEST_PASS};
+ test_result=${TEST_PASS};
fi
exit ${TEST_RESULT}
--- /dev/null
+(* TEST
+include config
+binary_modules = "config build_path_prefix_map misc"
+* bytecode
+*)
+
+open Misc
+open Magic_number
+
+(* sanity checking: the magic number at a given kind can be parsed back *)
+let error kind test =
+ fatal_errorf
+ "Internal compiler error (%s): there is a magic number mismatch on kind %s"
+ test
+ (string_of_kind kind)
+
+let check_raw_kind kind =
+ let valid =
+ match parse_kind (raw_kind kind) with
+ | None -> false
+ | Some kind_roundtrip ->
+ kind_roundtrip = kind
+ in
+ if not valid then error kind "raw_kind"
+
+let check_current_raw kind =
+ let valid =
+ match parse (current_raw kind) with
+ | Error _ -> false
+ | Ok magic ->
+ magic.kind = kind
+ && raw magic = current_raw kind
+ in
+ if not valid then error kind "current_raw"
+
+let () =
+ all_kinds
+ |> List.iter (fun kind -> check_raw_kind kind; check_current_raw kind)
15 | let d = (fun x -> x) [@inline malformed attribute] (* rejected *)
^^^^^^
Warning 47: illegal payload for attribute 'inline'.
-It must be either 'never', 'always' or empty
+It must be either 'never', 'always', 'hint' or empty
File "w47_inline.ml", line 16, characters 23-29:
16 | let e = (fun x -> x) [@inline malformed_attribute] (* rejected *)
^^^^^^
Warning 47: illegal payload for attribute 'inline'.
-It must be either 'never', 'always' or empty
+It must be either 'never', 'always', 'hint' or empty
File "w47_inline.ml", line 17, characters 23-29:
17 | let f = (fun x -> x) [@inline : malformed_attribute] (* rejected *)
^^^^^^
Warning 47: illegal payload for attribute 'inline'.
-It must be either 'never', 'always' or empty
+It must be either 'never', 'always', 'hint' or empty
File "w47_inline.ml", line 18, characters 23-29:
18 | let g = (fun x -> x) [@inline ? malformed_attribute] (* rejected *)
^^^^^^
Warning 47: illegal payload for attribute 'inline'.
-It must be either 'never', 'always' or empty
+It must be either 'never', 'always', 'hint' or empty
File "w47_inline.ml", line 23, characters 15-22:
23 | let k x = (a [@inlined malformed]) x (* rejected *)
^^^^^^^
Warning 47: illegal payload for attribute 'inlined'.
-It must be either 'never', 'always' or empty
+It must be either 'never', 'always', 'hint' or empty
File "w47_inline.ml", line 31, characters 7-12:
31 | let[@local malformed] f3 x = x (* bad payload *) in
^^^^^
^^^^^^^^^^^^^^^^
Warning 55: Cannot inline: [@inlined] attributes may not be used on partial applications
File "w55.ml", line 29, characters 10-27:
-29 | let i x = (!h [@inlined]) x
+29 | let i x = (!r [@inlined]) x
^^^^^^^^^^^^^^^^^
Warning 55: Cannot inline: [@inlined] attribute was not used on this function application (the optimizer did not know what function was being applied)
File "w55.ml", line 39, characters 12-30:
let g x = (f [@inlined]) x
-let h = ref f
+let r = ref f
-let i x = (!h [@inlined]) x
+let i x = (!r [@inlined]) x
let j x y = x + y
let c x = x + 1 [@@inline never]
let d x = (c [@inlined]) x
+
+let g' x = (f [@inlined hint]) x
+
+let i' x = (!r [@inlined hint]) x
+
+let h' x = (j [@inlined hint]) x
+
+let b' x y = (a [@inlined hint]) x y
+
+let d' x = (c [@inlined hint]) x
^^^^^^^^^^^^^^^^
Warning 55: Cannot inline: Function information unavailable
File "w55.ml", line 29, characters 10-27:
-29 | let i x = (!h [@inlined]) x
+29 | let i x = (!r [@inlined]) x
^^^^^^^^^^^^^^^^^
Warning 55: Cannot inline: Unknown function
File "w55.ml", line 33, characters 10-26:
#* *
#**************************************************************************
+.NOTPARALLEL:
+
TOPDIR = ../..
COMPILERLIBSDIR = $(TOPDIR)/compilerlibs
.PHONY: clean
clean:
- rm -f *.cm* *.$(O)
- rm -f $(tools)
+ rm -f *.cm* *.o *.obj
+ rm -f expect_test expect_test.exe codegen codegen.exe
rm -f parsecmm.ml parsecmm.mli lexcmm.ml
--- /dev/null
+/**************************************************************************/
+/* */
+/* OCaml */
+/* */
+/* Nicolas Ojeda Bar <n.oje.bar@gmail.com> */
+/* */
+/* Copyright 2019 Institut National de Recherche en Informatique et */
+/* en Automatique. */
+/* */
+/* All rights reserved. This file is distributed under the terms of */
+/* the GNU Lesser General Public License version 2.1, with the */
+/* special exception on linking described in the file LICENSE. */
+/* */
+/**************************************************************************/
+
+#define STORE sd
+#define LOAD ld
+
+ .globl call_gen_code
+ .align 2
+call_gen_code:
+ /* Set up stack frame and save callee-save registers */
+ ADDI sp, sp, -208
+ STORE ra, 192(sp)
+ STORE s0, 0(sp)
+ STORE s1, 8(sp)
+ STORE s2, 16(sp)
+ STORE s3, 24(sp)
+ STORE s4, 32(sp)
+ STORE s5, 40(sp)
+ STORE s6, 48(sp)
+ STORE s7, 56(sp)
+ STORE s8, 64(sp)
+ STORE s9, 72(sp)
+ STORE s10, 80(sp)
+ STORE s11, 88(sp)
+ fsd fs0, 96(sp)
+ fsd fs1, 104(sp)
+ fsd fs2, 112(sp)
+ fsd fs3, 120(sp)
+ fsd fs4, 128(sp)
+ fsd fs5, 136(sp)
+ fsd fs6, 144(sp)
+ fsd fs7, 152(sp)
+ fsd fs8, 160(sp)
+ fsd fs9, 168(sp)
+ fsd fs10, 176(sp)
+ fsd fs11, 184(sp)
+ /* Shuffle arguments */
+ mv t0, a0
+ mv a0, a1
+ mv a1, a2
+ mv a2, a3
+ mv a3, a4
+ /* Call generated asm */
+ jalr t0
+ /* Reload callee-save registers and return address */
+ LOAD ra, 192(sp)
+ LOAD s0, 0(sp)
+ LOAD s1, 8(sp)
+ LOAD s2, 16(sp)
+ LOAD s3, 24(sp)
+ LOAD s4, 32(sp)
+ LOAD s5, 40(sp)
+ LOAD s6, 48(sp)
+ LOAD s7, 56(sp)
+ LOAD s8, 64(sp)
+ LOAD s9, 72(sp)
+ LOAD s10, 80(sp)
+ LOAD s11, 88(sp)
+ fld fs0, 96(sp)
+ fld fs1, 104(sp)
+ fld fs2, 112(sp)
+ fld fs3, 120(sp)
+ fld fs4, 128(sp)
+ fld fs5, 136(sp)
+ fld fs6, 144(sp)
+ fld fs7, 152(sp)
+ fld fs8, 160(sp)
+ fld fs9, 168(sp)
+ fld fs10, 176(sp)
+ fld fs11, 184(sp)
+ addi sp, sp, 208
+ ret
+
+ .globl caml_c_call
+ .align 2
+caml_c_call:
+ jr t2
in
let string_constant (e : Parsetree.expression) =
match e.pexp_desc with
- | Pexp_constant (Pconst_string (str, Some tag)) ->
+ | Pexp_constant (Pconst_string (str, _, Some tag)) ->
{ str; tag }
| _ -> invalid_payload ()
in
"intoffloat", INTOFFLOAT;
"string", KSTRING;
"let", LET;
+ "letmut", LETMUT;
"load", LOAD;
"mod", MODI;
"mulh", MULH;
unbind_ident id;
Clet(id, def, make_letdef rem body)
+let rec make_letmutdef def body =
+ match def with
+ [] -> body
+ | (id, ty, def) :: rem ->
+ unbind_ident id;
+ Clet_mut(id, ty, def, make_letmutdef rem body)
+
let make_switch n selector caselist =
let index = Array.make n 0 in
let casev = Array.of_list caselist in
%token LEF
%token LEI
%token LET
+%token LETMUT
%token LOAD
%token <Location.t> LOCATION
%token LPAREN
| IDENT { Cvar(find_ident $1) }
| LBRACKET RBRACKET { Ctuple [] }
| LPAREN LET letdef sequence RPAREN { make_letdef $3 $4 }
+ | LPAREN LETMUT letmutdef sequence RPAREN { make_letmutdef $3 $4 }
| LPAREN ASSIGN IDENT expr RPAREN { Cassign(find_ident $3, $4) }
| LPAREN APPLY location expr exprlist machtype RPAREN
{ Cop(Capply $6, $4 :: List.rev $5, debuginfo ?loc:$3 ()) }
oneletdef:
IDENT expr { (bind_ident $1, $2) }
;
+letmutdef:
+ oneletmutdef { [$1] }
+ | LPAREN letmutdefmult RPAREN { $2 }
+;
+letmutdefmult:
+ /**/ { [] }
+ | oneletmutdef letmutdefmult { $1 :: $2 }
+;
+oneletmutdef:
+ IDENT machtype expr { (bind_ident $1, $2, $3) }
+;
chunk:
UNSIGNED BYTE { Byte_unsigned }
| SIGNED BYTE { Byte_signed }
prerr_string "Unbound identifier "; prerr_string s; prerr_endline "."
let debuginfo ?(loc=Location.symbol_rloc ()) () =
- Debuginfo.(from_location loc)
+ Debuginfo.(from_location (Scoped_location.of_location ~scopes:[] loc))
../bytecomp/bytesections.cmi
cmpbyt.cmx : \
../bytecomp/bytesections.cmx
-cmt2annot.cmo : \
- ../typing/untypeast.cmi \
- ../typing/types.cmi \
- ../typing/typedtree.cmi \
- ../typing/tast_iterator.cmi \
- ../typing/stypes.cmi \
- ../parsing/pprintast.cmi \
- ../typing/path.cmi \
- ../typing/oprint.cmi \
- ../parsing/location.cmi \
- ../utils/load_path.cmi \
- ../typing/ident.cmi \
- ../typing/envaux.cmi \
- ../typing/env.cmi \
- ../file_formats/cmt_format.cmi \
- ../parsing/asttypes.cmi \
- ../typing/annot.cmi
-cmt2annot.cmx : \
- ../typing/untypeast.cmx \
- ../typing/types.cmx \
- ../typing/typedtree.cmx \
- ../typing/tast_iterator.cmx \
- ../typing/stypes.cmx \
- ../parsing/pprintast.cmx \
- ../typing/path.cmx \
- ../typing/oprint.cmx \
- ../parsing/location.cmx \
- ../utils/load_path.cmx \
- ../typing/ident.cmx \
- ../typing/envaux.cmx \
- ../typing/env.cmx \
- ../file_formats/cmt_format.cmx \
- ../parsing/asttypes.cmi \
- ../typing/annot.cmi
cvt_emit.cmo :
cvt_emit.cmx :
dumpobj.cmo : \
profiling.cmi
profiling.cmi :
read_cmt.cmo : \
+ ../typing/untypeast.cmi \
+ ../typing/stypes.cmi \
+ ../parsing/pprintast.cmi \
../parsing/location.cmi \
+ ../utils/load_path.cmi \
+ ../typing/envaux.cmi \
../driver/compmisc.cmi \
../file_formats/cmt_format.cmi \
- cmt2annot.cmo \
- ../utils/clflags.cmi
+ ../typing/cmt2annot.cmo \
+ ../utils/clflags.cmi \
+ ../typing/annot.cmi
read_cmt.cmx : \
+ ../typing/untypeast.cmx \
+ ../typing/stypes.cmx \
+ ../parsing/pprintast.cmx \
../parsing/location.cmx \
+ ../utils/load_path.cmx \
+ ../typing/envaux.cmx \
../driver/compmisc.cmx \
../file_formats/cmt_format.cmx \
- cmt2annot.cmx \
- ../utils/clflags.cmx
+ ../typing/cmt2annot.cmx \
+ ../utils/clflags.cmx \
+ ../typing/annot.cmi
stripdebug.cmo : \
../utils/misc.cmi \
../bytecomp/bytesections.cmi
MAKEFLAGS := -r -R
ROOTDIR = ..
-include $(ROOTDIR)/Makefile.config
-include $(ROOTDIR)/Makefile.common
+-include $(ROOTDIR)/Makefile.config
+-include $(ROOTDIR)/Makefile.common
ifeq ($(SYSTEM),unix)
override define shellquote
$(ROOTDIR)/compilerlibs/ocamlcommon.cma \
$(ROOTDIR)/compilerlibs/ocamlbytecomp.cma \
\
- cmt2annot.cmo read_cmt.cmo
+ read_cmt.cmo
# Reading cmt files
$(call byte_and_opt,read_cmt,$(READ_CMT),)
lintapidiff.opt: $(LINTAPIDIFF)
$(CAMLOPT_CMD) $(LINKFLAGS) -I $(ROOTDIR) -o $@ $(LINTAPIDIFF)
clean::
- rm -f -- lintapidiff.opt lintapidiff.cm? lintapidiff.o
+ rm -f -- lintapidiff.opt lintapidiff.cm? lintapidiff.o lintapidiff.obj
clean::
- rm -f "objinfo_helper$(EXE)" "objinfo_helper$(EXE).manifest"
+ rm -f "objinfo_helper" "objinfo_helper.manifest"
+ rm -f "objinfo_helper.exe" "objinfo_helper.exe.manifest"
+# Eventlog metadata file
+
+install::
+ $(INSTALL_DATA) \
+ eventlog_metadata \
+ "$(INSTALL_LIBDIR)"
# Copy a bytecode executable, stripping debug info
$(call byte_and_opt,cmpbyt,$(CMPBYT),)
-ifeq "$(RUNTIMEI)" "true"
-install::
- $(INSTALL_PROG) \
- ocaml-instr-graph ocaml-instr-report \
- "$(INSTALL_BINDIR)/"
-endif
-
CAMLTEX= $(ROOTDIR)/compilerlibs/ocamlcommon.cma \
$(ROOTDIR)/compilerlibs/ocamlbytecomp.cma \
$(ROOTDIR)/compilerlibs/ocamltoplevel.cma \
--- /dev/null
+#!/bin/sh -e
+#**************************************************************************
+#* *
+#* OCaml *
+#* *
+#* David Allsopp, MetaStack Solutions Ltd. *
+#* *
+#* Copyright 2019 MetaStack Solutions Ltd. *
+#* *
+#* All rights reserved. This file is distributed under the terms of *
+#* the GNU Lesser General Public License version 2.1, with the *
+#* special exception on linking described in the file LICENSE. *
+#* *
+#**************************************************************************
+
+# Remove the autom4te.cache directory to make sure we start in a clean state
+rm -rf autom4te.cache
+
+autoconf --force --warnings=all,error
+
+# Allow pre-processing of configure arguments for Git check-outs
+# The sed call removes dra27's copyright on the whole configure script...
+sed -e '/^#[^!]/d' tools/git-dev-options.sh > configure.tmp
+
+# Some distros have the 2013 --runstatedir patch to autoconf (see
+# http://git.savannah.gnu.org/cgit/autoconf.git/commit/?id=a197431414088a417b407b9b20583b2e8f7363bd
+# in the GNU autoconf repo), and some don't, so ensure its effects are
+# removed for CI consistency...
+# POSIX Notes
+# - sed -i without a backup file is not portable, hence configure.tmp
+# - GNU sed's /../,+8d becomes /../{N;..;d;} (and the last ; is important)
+sed -e '/^runstatedir/d' \
+ -e '/-runstatedir /{N;N;N;N;N;N;N;N;d;}' \
+ -e '/--runstatedir=DIR/d' \
+ -e 's/ runstatedir//' \
+ -e '1d' \
+ configure >> configure.tmp
+
+mv -f configure.tmp configure
+chmod +x configure
[ -z "$*" ] && { echo "Usage: $0 libfoo.a" 1>&2; exit 2; }
-nm -A -P "$@" | awk '
+nm -A -P "$@" | LC_ALL=C awk '
# ignore caml_foo, camlFoo_bar, _caml_foo, _camlFoo_bar
$2 ~ /^(_?caml[_A-Z])/ { next }
# ignore local and undefined symbols
-$3 ~ /^[rbdtsU]$/ { next }
+$3 ~ /^[a-zU]$/ { next }
# ignore "main", which should be externally linked
$2 ~ /^_?main$/ { next }
+$2 ~ /^_?wmain$/ { next }
+# Caml_state escapes the prefixing rule for now
+$2 ~ /^_?Caml_state$/ { next }
+# for x86 PIC mode
+$2 ~ /^__x86.get_pc_thunk./ { next }
+# for mingw32
+$2 ~ /^.debug_/ { next }
+# windows unicode support
+$2 ~ /^_win_multi_byte_to_wide_char$/ { next }
+$2 ~ /^_win_wide_char_to_multi_byte$/ { next }
# print the rest
{ found=1; print $1 " " $2 " " $3 }
# fail if there were any results
@rem Do not call setlocal!\r
@echo off\r
\r
-goto %1\r
+if "%1" neq "install" goto %1\r
+setlocal enabledelayedexpansion\r
+echo AppVeyor Environment\r
+for %%K in (ACCOUNT_NAME ACS_DEPLOYMENT_UPGRADE_MODE API_URL\r
+ ARTIFACT_UPLOAD_TIMEOUT BUILD_FOLDER BUILD_ID BUILD_NUMBER\r
+ BUILD_VERSION BUILD_WORKER_IMAGE BUILD_WORKER_IMAGE\r
+ CACHE_ENTRY_UPLOAD_DOWNLOAD_TIMEOUT CACHE_SKIP_RESTORE\r
+ CACHE_SKIP_SAVE FILE_DOWNLOAD_TIMEOUT FORCED_BUILD\r
+ IGNORE_COMMIT_FILTERING_ON_TAG JOB_ID JOB_NAME JOB_NUMBER PROJECT_ID\r
+ PROJECT_NAME PROJECT_SLUG PULL_REQUEST_HEAD_COMMIT\r
+ PULL_REQUEST_HEAD_REPO_BRANCH PULL_REQUEST_HEAD_REPO_NAME\r
+ PULL_REQUEST_NUMBER PULL_REQUEST_TITLE RE_BUILD REPO_BRANCH\r
+ REPO_COMMIT_AUTHOR REPO_COMMIT_AUTHOR_EMAIL REPO_COMMIT\r
+ REPO_COMMIT_MESSAGE REPO_COMMIT_MESSAGE_EXTENDED\r
+ REPO_COMMIT_TIMESTAMP REPO_NAME REPO_PROVIDER REPO_SCM\r
+ REPOSITORY_SHALLOW_CLONE_TIMEOUT REPO_TAG_NAME REPO_TAG\r
+ RE_RUN_INCOMPLETE SAVE_CACHE_ON_ERROR SCHEDULED_BUILD\r
+ SKIP_FINALIZE_ON_EXIT APPVEYOR URL WAP_ARTIFACT_NAME\r
+ WAP_SKIP_ACLS) do echo APPVEYOR_%%K=!APPVEYOR_%%K!\r
+echo CI=%CI%\r
+echo CONFIGURATION=%CONFIGURATION%\r
+echo PLATFORM=%PLATFORM%\r
+endlocal\r
+\r
+goto install\r
\r
goto :EOF\r
\r
BUILD_PID=0
+# This must correspond with the entry in appveyor.yml
+CACHE_DIRECTORY=/cygdrive/c/projects/cache
+
+if [[ -z $APPVEYOR_PULL_REQUEST_HEAD_COMMIT ]] ; then
+ MAKE="make -j"
+else
+ MAKE=make
+fi
+
function run {
+ if [[ $1 = "--show" ]] ; then SHOW_CMD='true'; shift; else SHOW_CMD=''; fi
NAME=$1
shift
echo "-=-=- $NAME -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-"
- "$@"
+ if [[ -n $SHOW_CMD ]]; then (set -x; "$@"); else "$@"; fi
CODE=$?
if [[ $CODE -ne 0 ]] ; then
echo "-=-=- $NAME failed! -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-"
;;
esac
- ./configure $build $host --prefix="$2"
+ mkdir -p "$CACHE_DIRECTORY"
+ ./configure --cache-file="$CACHE_DIRECTORY/config.cache-$1" \
+ $build $host --prefix="$2" --enable-ocamltest || ( \
+ rm -f "$CACHE_DIRECTORY/config.cache-$1" ; \
+ ./configure --cache-file="$CACHE_DIRECTORY/config.cache-$1" \
+ $build $host --prefix="$2" --enable-ocamltest )
FILE=$(pwd | cygpath -f - -m)/Makefile.config
echo "Edit $FILE to turn C compiler warnings into errors"
set_configuration msvc "$OCAMLROOT-msvc32" -WX
- run 'make world' make world
- run 'make runtimeopt' make runtimeopt
- run 'make -C otherlibs/systhreads libthreadsnat.lib' \
- make -C otherlibs/systhreads libthreadsnat.lib
+ run "$MAKE world" $MAKE world
+ run "$MAKE runtimeopt" $MAKE runtimeopt
+ run "$MAKE -C otherlibs/systhreads libthreadsnat.lib" \
+ $MAKE -C otherlibs/systhreads libthreadsnat.lib
exit 0
;;
test)
FULL_BUILD_PREFIX="$APPVEYOR_BUILD_FOLDER/../$BUILD_PREFIX"
run 'ocamlc.opt -version' "$FULL_BUILD_PREFIX-$PORT/ocamlc.opt" -version
- run "test $PORT" make -C "$FULL_BUILD_PREFIX-$PORT" tests
- run "install $PORT" make -C "$FULL_BUILD_PREFIX-$PORT" install
+ if [[ $PORT = 'mingw32' ]] ; then
+ run "Check runtime symbols" \
+ "$FULL_BUILD_PREFIX-$PORT/tools/check-symbol-names" \
+ $FULL_BUILD_PREFIX-$PORT/runtime/*.a
+ fi
+ run "test $PORT" $MAKE -C "$FULL_BUILD_PREFIX-$PORT" tests
+ run "install $PORT" $MAKE -C "$FULL_BUILD_PREFIX-$PORT" install
if [[ $PORT = 'msvc64' ]] ; then
- run 'check_all_arches' make -C "$FULL_BUILD_PREFIX-$PORT" check_all_arches
+ run "$MAKE check_all_arches" \
+ $MAKE -C "$FULL_BUILD_PREFIX-$PORT" check_all_arches
+ cd "$FULL_BUILD_PREFIX-$PORT"
+ # Ensure that .gitignore is up-to-date - this will fail if any untracked
+ # or altered files exist. We revert the change from the bootstrap (that
+ # would have failed the build earlier if necessary)
+ git checkout -- boot/ocamlc boot/ocamllex
+ # Remove the FlexDLL sources placed earlier in the process
+ rm -rf "flexdll-$FLEXDLL_VERSION"
+ run --show "Check tree is tracked" test -z "$(git status --porcelain)"
+ # check that the `distclean` target definitely cleans the tree
+ run "$MAKE distclean" $MAKE distclean
+ # Check the working tree is clean
+ run --show "Check tree is tracked" test -z "$(git status --porcelain)"
+ # Check that there are no ignored files
+ run --show "Check tree is clean" \
+ test -z "$(git ls-files --others -i --exclude-standard)"
fi
;;
*)
cd "$APPVEYOR_BUILD_FOLDER/../$BUILD_PREFIX-$PORT"
if [[ $PORT = 'msvc64' ]] ; then
+ # Ensure that make distclean can be run from an empty tree
+ run "$MAKE distclean" $MAKE distclean
tar -xzf "$APPVEYOR_BUILD_FOLDER/flexdll.tar.gz"
cd "flexdll-$FLEXDLL_VERSION"
- make MSVC_DETECT=0 CHAINS=msvc64 support
+ $MAKE MSVC_DETECT=0 CHAINS=msvc64 support
cp flexdll*_msvc64.obj "$OCAMLROOT/bin/flexdll/"
cd ..
fi
# For an explanation of the sed command, see
# https://github.com/appveyor/ci/issues/1824
script --quiet --return --command \
- "make -C ../$BUILD_PREFIX-mingw32 flexdll world.opt" \
+ "$MAKE -C ../$BUILD_PREFIX-mingw32 flexdll && "\
+"$MAKE -C ../$BUILD_PREFIX-mingw32 world.opt" \
"../$BUILD_PREFIX-mingw32/build.log" |
sed -e 's/\d027\[K//g' \
-e 's/\d027\[m/\d027[0m/g' \
-e 's/\d027\[01\([m;]\)/\d027[1\1/g'
else
- run 'make world' make world
- run 'make bootstrap' make bootstrap
- run 'make opt' make opt
- run 'make opt.opt' make opt.opt
+ run "$MAKE world" $MAKE world
+ run "$MAKE bootstrap" $MAKE bootstrap
+ run "$MAKE opt" $MAKE opt
+ run "$MAKE opt.opt" $MAKE opt.opt
fi
;;
# default values
make=make
instdir="$HOME/ocaml-tmp-install"
-confoptions="${OCAML_CONFIGURE_OPTIONS}"
+confoptions="--enable-ocamltest ${OCAML_CONFIGURE_OPTIONS}"
make_native=true
cleanup=false
check_make_alldepend=false
--- /dev/null
+#!/bin/sh
+
+#**************************************************************************
+#* *
+#* OCaml *
+#* *
+#* Xavier Leroy, projet Cambium, INRIA Paris-Rocquencourt *
+#* *
+#* Copyright 2020 Institut National de Recherche en Informatique et *
+#* en Automatique. *
+#* *
+#* All rights reserved. This file is distributed under the terms of *
+#* the GNU Lesser General Public License version 2.1, with the *
+#* special exception on linking described in the file LICENSE. *
+#* *
+#**************************************************************************
+
+# Test the Dune-based build
+
+set -ex
+eval $(opam env)
+export LC_ALL=C
+git clean -q -f -d -x
+./configure
+dune build -j2 @libs
fi
# A tool that make error backtrace nicer
-# Need to pick the one that matches clang-6.0 and is named "llvm-symbolizer"
-# (/usr/bin/llvm-symbolizer-6.0 doesn't work, that would be too easy)
-export ASAN_SYMBOLIZER_PATH=/usr/lib/llvm-6.0/bin/llvm-symbolizer
+# Need to pick the one that matches clang-9 and is named "llvm-symbolizer"
+# (/usr/bin/llvm-symbolizer-9 doesn't work, that would be too easy)
+export ASAN_SYMBOLIZER_PATH=/usr/lib/llvm-9/bin/llvm-symbolizer
export TSAN_SYMBOLIZER_PATH="$ASAN_SYMBOLIZER_PATH"
#########################################################################
+# Cleanup repository
+git clean -q -f -d -x
+
# Ensure that the repo still passes the check-typo script
if [ ! -x tools/check-typo ] ; then
error "tools/check-typo does not appear to be executable?"
echo "======== old school build =========="
-git clean -q -f -d -x
-
instdir="$HOME/ocaml-tmp-install-$$"
./configure --prefix "$instdir"
#########################################################################
-echo "======== clang 6.0, address sanitizer, UB sanitizer =========="
+echo "======== clang 9, address sanitizer, UB sanitizer =========="
git clean -q -f -d -x
-# Use clang 6.0
+# Use clang 9
# We cannot give the sanitizer options as part of -cc because
# then various autoconfiguration tests fail.
# Instead, we'll fix OC_CFLAGS a posteriori.
-./configure CC=clang-6.0
+./configure CC=clang-9 --disable-stdlib-manpages
# These are the undefined behaviors we want to check
# Others occur on purpose e.g. signed arithmetic overflow
# occurs.
# We already use sigaltstack for stack overflow detection. Our use
-# interracts with ASAN's. Hence, we tell ASAN not to use it.
+# interacts with ASAN's. Hence, we tell ASAN not to use it.
ASAN_OPTIONS="detect_leaks=0,use_sigaltstack=0" $run_testsuite
#########################################################################
-echo "======== clang 6.0, thread sanitizer =========="
+echo "======== clang 9, thread sanitizer =========="
git clean -q -f -d -x
-./configure CC=clang-6.0
+./configure CC=clang-9 --disable-stdlib-manpages
# Select thread sanitizer
# Don't optimize too much to get better backtraces of errors
# # Instead, we'll fix OC_CFLAGS a posteriori.
# # Memory sanitizer doesn't like the static data generated by ocamlopt,
# # hence build bytecode only
-# ./configure CC=clang-6.0 --disable-native-compiler
+# ./configure CC=clang-9 --disable-native-compiler
# # Select memory sanitizer
# # Don't optimize at all to get better backtraces of errors
conffile=Makefile.config
make=make
instdir="$HOME/ocaml-tmp-install"
-confoptions="${OCAML_CONFIGURE_OPTIONS}"
+confoptions="--enable-ocamltest ${OCAML_CONFIGURE_OPTIONS}"
make_native=true
cleanup=false
check_make_alldepend=false
------------------------------------------------------------------------
EOF
+ # Ensure that make distclean can be run from an empty tree
+ $MAKE distclean
+
if [ "$MIN_BUILD" = "1" ] ; then
configure_flags="\
--prefix=$PREFIX \
--disable-bigarray-lib \
--disable-ocamldoc \
--disable-native-compiler \
+ --enable-ocamltest \
$CONFIG_ARG"
else
configure_flags="\
--prefix=$PREFIX \
--enable-flambda-invariants \
+ --enable-ocamltest \
$CONFIG_ARG"
fi
case $XARCH in
$MAKE world.opt
$MAKE ocamlnat
fi
+ echo Ensuring that all names are prefixed in the runtime
+ ./tools/check-symbol-names runtime/*.a
cd testsuite
echo Running the testsuite with the normal runtime
$MAKE all
# we would need to redo (small parts of) world.opt afterwards to
# use the compiler again
$MAKE check_all_arches
+ # Ensure that .gitignore is up-to-date - this will fail if any untreacked or
+ # altered files exist.
+ test -z "$(git status --porcelain)"
# check that the 'clean' target also works
$MAKE clean
+ $MAKE -C manual clean
+ # check that the `distclean` target definitely cleans the tree
+ $MAKE distclean
+ # Check the working tree is clean
+ test -z "$(git status --porcelain)"
+ # Check that there are no ignored files
+ test -z "$(git ls-files --others -i --exclude-standard)"
}
CheckChangesModified () {
echo 'Verifying that configure.ac generates configure'
git checkout "$1"
mv configure configure.ref
- ./autogen
+ make configure
if ! diff -q configure configure.ref >/dev/null ; then
echo "configure.ac no longer generates configure, \
-please run ./autogen and commit"
+please run rm configure ; make configure and commit"
exit 1
fi
fi
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* OCaml *)
-(* *)
-(* Fabrice Le Fessant, INRIA Saclay *)
-(* *)
-(* Copyright 2012 Institut National de Recherche en Informatique et *)
-(* en Automatique. *)
-(* *)
-(* All rights reserved. This file is distributed under the terms of *)
-(* the GNU Lesser General Public License version 2.1, with the *)
-(* special exception on linking described in the file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* Generate an .annot file from a .cmt file. *)
-
-open Asttypes
-open Typedtree
-open Tast_iterator
-
-let variables_iterator scope =
- let super = default_iterator in
- let pat sub p =
- begin match p.pat_desc with
- | Tpat_var (id, _) | Tpat_alias (_, id, _) ->
- Stypes.record (Stypes.An_ident (p.pat_loc,
- Ident.name id,
- Annot.Idef scope))
- | _ -> ()
- end;
- super.pat sub p
- in
- {super with pat}
-
-let bind_variables scope =
- let iter = variables_iterator scope in
- fun p -> iter.pat iter p
-
-let bind_bindings scope bindings =
- let o = bind_variables scope in
- List.iter (fun x -> o x.vb_pat) bindings
-
-let bind_cases l =
- List.iter
- (fun {c_lhs; c_guard; c_rhs} ->
- let loc =
- let open Location in
- match c_guard with
- | None -> c_rhs.exp_loc
- | Some g -> {c_rhs.exp_loc with loc_start=g.exp_loc.loc_start}
- in
- bind_variables loc c_lhs
- )
- l
-
-let record_module_binding scope mb =
- Stypes.record (Stypes.An_ident
- (mb.mb_name.loc,
- Option.value mb.mb_name.txt ~default:"_",
- Annot.Idef scope))
-
-let rec iterator ~scope rebuild_env =
- let super = default_iterator in
- let class_expr sub node =
- Stypes.record (Stypes.Ti_class node);
- super.class_expr sub node
-
- and module_expr _sub node =
- Stypes.record (Stypes.Ti_mod node);
- super.module_expr (iterator ~scope:node.mod_loc rebuild_env) node
-
- and expr sub exp =
- begin match exp.exp_desc with
- | Texp_ident (path, _, _) ->
- let full_name = Path.name ~paren:Oprint.parenthesized_ident path in
- let env =
- if rebuild_env then
- try
- Env.env_of_only_summary Envaux.env_from_summary exp.exp_env
- with Envaux.Error err ->
- Format.eprintf "%a@." Envaux.report_error err;
- exit 2
- else
- exp.exp_env
- in
- let annot =
- try
- let desc = Env.find_value path env in
- let dloc = desc.Types.val_loc in
- if dloc.Location.loc_ghost then Annot.Iref_external
- else Annot.Iref_internal dloc
- with Not_found ->
- Annot.Iref_external
- in
- Stypes.record
- (Stypes.An_ident (exp.exp_loc, full_name , annot))
- | Texp_let (Recursive, bindings, _) ->
- bind_bindings exp.exp_loc bindings
- | Texp_let (Nonrecursive, bindings, body) ->
- bind_bindings body.exp_loc bindings
- | Texp_match (_, f1, _) ->
- bind_cases f1
- | Texp_function { cases = f; }
- | Texp_try (_, f) ->
- bind_cases f
- | Texp_letmodule (_, modname, _, _, body ) ->
- Stypes.record (Stypes.An_ident
- (modname.loc,Option.value ~default:"_" modname.txt,
- Annot.Idef body.exp_loc))
- | _ -> ()
- end;
- Stypes.record (Stypes.Ti_expr exp);
- super.expr sub exp
-
- and pat sub p =
- Stypes.record (Stypes.Ti_pat p);
- super.pat sub p
- in
-
- let structure_item_rem sub str rem =
- let open Location in
- let loc = str.str_loc in
- begin match str.str_desc with
- | Tstr_value (rec_flag, bindings) ->
- let doit loc_start = bind_bindings {scope with loc_start} bindings in
- begin match rec_flag, rem with
- | Recursive, _ -> doit loc.loc_start
- | Nonrecursive, [] -> doit loc.loc_end
- | Nonrecursive, {str_loc = loc2} :: _ -> doit loc2.loc_start
- end
- | Tstr_module mb ->
- record_module_binding
- { scope with Location.loc_start = loc.loc_end } mb
- | Tstr_recmodule mbs ->
- List.iter (record_module_binding
- { scope with Location.loc_start = loc.loc_start }) mbs
- | _ ->
- ()
- end;
- Stypes.record_phrase loc;
- super.structure_item sub str
- in
- let structure_item sub s =
- (* This will be used for Partial_structure_item.
- We don't have here the location of the "next" item,
- this will give a slightly different scope for the non-recursive
- binding case. *)
- structure_item_rem sub s []
- in
- let structure sub l =
- let rec loop = function
- | str :: rem -> structure_item_rem sub str rem; loop rem
- | [] -> ()
- in
- loop l.str_items
- in
- {super with class_expr; module_expr; expr; pat; structure_item; structure}
-
-let binary_part iter x =
- let open Cmt_format in
- match x with
- | Partial_structure x -> iter.structure iter x
- | Partial_structure_item x -> iter.structure_item iter x
- | Partial_expression x -> iter.expr iter x
- | Partial_pattern x -> iter.pat iter x
- | Partial_class_expr x -> iter.class_expr iter x
- | Partial_signature x -> iter.signature iter x
- | Partial_signature_item x -> iter.signature_item iter x
- | Partial_module_type x -> iter.module_type iter x
-
-(* Save cmt information as faked annotations, attached to
- Location.none, on top of the .annot file. Only when -save-cmt-info is
- provided to ocaml_cmt.
-*)
-let record_cmt_info cmt =
- let location_none = {
- Location.none with Location.loc_ghost = false }
- in
- let location_file file = {
- Location.none with
- Location.loc_start = {
- Location.none.Location.loc_start with
- Lexing.pos_fname = file }}
- in
- let record_info name value =
- let ident = Printf.sprintf ".%s" name in
- Stypes.record (Stypes.An_ident (location_none, ident,
- Annot.Idef (location_file value)))
- in
- let open Cmt_format in
- (* record in reverse order to get them in correct order... *)
- List.iter (fun dir -> record_info "include" dir) (List.rev cmt.cmt_loadpath);
- record_info "chdir" cmt.cmt_builddir;
- (match cmt.cmt_sourcefile with
- None -> () | Some file -> record_info "source" file)
-
-let gen_annot ?(save_cmt_info=false) target_filename filename cmt =
- let open Cmt_format in
- Envaux.reset_cache ();
- List.iter Load_path.add_dir (List.rev cmt.cmt_loadpath);
- let target_filename =
- match target_filename with
- | None -> Some (filename ^ ".annot")
- | Some "-" -> None
- | Some _ -> target_filename
- in
- if save_cmt_info then record_cmt_info cmt;
- let iter = iterator ~scope:Location.none cmt.cmt_use_summaries in
- match cmt.cmt_annots with
- | Implementation typedtree ->
- iter.structure iter typedtree;
- Stypes.dump target_filename
- | Interface _ ->
- Printf.eprintf "Cannot generate annotations for interface file\n%!";
- exit 2
- | Partial_implementation parts ->
- Array.iter (binary_part iter) parts;
- Stypes.dump target_filename
- | Packed _ ->
- Printf.fprintf stderr "Packed files not yet supported\n%!";
- Stypes.dump target_filename
- | Partial_interface _ ->
- Printf.fprintf stderr "File was generated with an error\n%!";
- exit 2
-
-let gen_ml target_filename filename cmt =
- let (printer, ext) =
- match cmt.Cmt_format.cmt_annots with
- | Cmt_format.Implementation typedtree ->
- (fun ppf -> Pprintast.structure ppf
- (Untypeast.untype_structure typedtree)),
- ".ml"
- | Cmt_format.Interface typedtree ->
- (fun ppf -> Pprintast.signature ppf
- (Untypeast.untype_signature typedtree)),
- ".mli"
- | _ ->
- Printf.fprintf stderr "File was generated with an error\n%!";
- exit 2
- in
- let target_filename = match target_filename with
- None -> Some (filename ^ ext)
- | Some "-" -> None
- | Some _ -> target_filename
- in
- let oc = match target_filename with
- None -> None
- | Some filename -> Some (open_out filename) in
- let ppf = match oc with
- None -> Format.std_formatter
- | Some oc -> Format.formatter_of_out_channel oc in
- printer ppf;
- Format.pp_print_flush ppf ();
- match oc with
- None -> flush stdout
- | Some oc -> close_out oc
let rec print_struct_const = function
Const_base(Const_int i) -> printf "%d" i
| Const_base(Const_float f) -> print_float f
- | Const_base(Const_string (s, _)) -> printf "%S" s
+ | Const_base(Const_string (s, _, _)) -> printf "%S" s
| Const_immstring s -> printf "%S" s
| Const_base(Const_char c) -> printf "%C" c
| Const_base(Const_int32 i) -> printf "%ldl" i
--- /dev/null
+/* CTF 1.8 */
+
+typealias integer {size = 8;} := uint8_t;
+typealias integer {size = 16;} := uint16_t;
+typealias integer {size = 32;} := uint32_t;
+typealias integer {size = 64;} := uint64_t;
+
+clock {
+ name = tracing_clock;
+ freq = 1000000000; /* tick = 1 ns */
+};
+
+typealias integer {
+ size = 64;
+ map = clock.tracing_clock.value;
+} := tracing_clock_int_t;
+
+
+/*
+
+Main trace description,
+major and minor refers to the CTF version being used.
+
+The packet header must contain at the very least
+a stream id and the CTF magic number.
+We only use one stream for now, and CTF magic number is 0xc1fc1fc1.
+
+We add an extra field ocaml_trace_version to enable simpler transition if we add
+or remove metrics in the future.
+
+*/
+trace {
+ major = 1;
+ minor = 8;
+ byte_order = @endianness@;
+ packet.header := struct {
+ uint32_t magic; /* required: must contain CTF magic number */
+ uint16_t ocaml_trace_version; /* our own trace format versioning */
+ uint16_t stream_id; /* required, although we have only one. */
+ };
+};
+
+/*
+
+We use only one stream at the moment.
+Each event payload must contain a header with a timestamp and a pid.
+The id field refers to the various event kinds defined further down this file.
+
+*/
+stream {
+ id = 0;
+ event.header := struct { /* for each event */
+ tracing_clock_int_t timestamp;
+ uint32_t pid;
+ uint32_t id;
+ };
+};
+
+/*
+
+These enumerations are mostly following the instrumented runtime datapoints.
+gc_phase aims to track the entry and exit time of each of the following events
+during collection.
+
+*/
+enum gc_phase : uint16_t {
+ "compact/main" = 0,
+ "compact/recompact",
+ "explicit/gc_set",
+ "explicit/gc_stat",
+ "explicit/gc_minor",
+ "explicit/gc_major",
+ "explicit/gc_full_major",
+ "explicit/gc_compact",
+ "major",
+ "major/roots",
+ "major/sweep",
+ "major/mark/roots",
+ "major/mark/main",
+ "major/mark/final",
+ "major/mark",
+ "major/mark/global_roots_slice",
+ "major_roots/global",
+ "major_roots/dynamic_global",
+ "major_roots/local",
+ "major_roots/C",
+ "major_roots/finalised",
+ "major_roots/memprof",
+ "major_roots/hook",
+ "major/check_and_compact",
+ "minor",
+ "minor/local_roots",
+ "minor/ref_tables",
+ "minor/copy",
+ "minor/update_weak",
+ "minor/finalized",
+ "explicit/gc_major_slice"
+};
+
+/*
+
+Miscellaneous GC counters
+
+*/
+enum gc_counter : uint16_t {
+ "alloc_jump",
+ "force_minor/alloc_small",
+ "force_minor/make_vect",
+ "force_minor/set_minor_heap_size",
+ "force_minor/weak",
+ "force_minor/memprof",
+ "major/mark/slice/remain",
+ "major/mark/slice/fields",
+ "major/mark/slice/pointers",
+ "major/work/extra",
+ "major/work/mark",
+ "major/work/sweep",
+ "minor/promoted",
+ "request_major/alloc_shr",
+ "request_major/adjust_gc_speed",
+ "request_minor/realloc_ref_table",
+ "request_minor/realloc_ephe_ref_table",
+ "request_minor/realloc_custom_table"
+};
+
+/*
+
+Block allocation counters, per size buckets.
+
+*/
+enum alloc_bucket : uint8_t {
+ "alloc 01" = 1,
+ "alloc 02",
+ "alloc 03",
+ "alloc 04",
+ "alloc 05",
+ "alloc 06",
+ "alloc 07",
+ "alloc 08",
+ "alloc 09",
+ "alloc 10-19",
+ "alloc 20-29",
+ "alloc 30-39",
+ "alloc 40-49",
+ "alloc 50-59",
+ "alloc 60-69",
+ "alloc 70-79",
+ "alloc 80-89",
+ "alloc 90-99",
+ "alloc large"
+};
+
+/*
+
+Each event is comprised of the previously defined event.header
+and the fields defined here.
+
+An entry event marks the start of a gc phase.
+
+*/
+event {
+ id = 0;
+ name = "entry";
+ stream_id = 0;
+ fields := struct {
+ enum gc_phase phase;
+ };
+};
+
+/*
+
+exit counterparts to entry events
+
+*/
+event {
+ id = 1;
+ name = "exit";
+ stream_id = 0;
+ fields := struct {
+ enum gc_phase phase;
+ };
+};
+
+event {
+ id = 2;
+ name = "counter";
+ stream_id = 0;
+ fields := struct {
+ uint64_t count;
+ enum gc_counter kind;
+ };
+};
+
+event {
+ id = 3;
+ name = "alloc";
+ stream_id = 0;
+ fields := struct {
+ uint64_t count;
+ enum alloc_bucket bucket;
+ };
+};
+
+/*
+ Flush events are used to track the time spent by the tracing runtime flushing
+ data to disk, useful to remove flushing overhead for other runtime mesurements
+ in the trace.
+*/
+event {
+ id = 4;
+ name = "flush";
+ stream_id = 0;
+ fields := struct {
+ tracing_clock_int_t duration;
+ };
+};
major="`echo "$version" | sed -n -e '1s/^\([0-9]*\)\..*/\1/p'`"
minor="`echo "$version" | sed -n -e '1s/^[0-9]*\.0*\([0-9]*\).*/\1/p'`"
patchlvl="`echo "$version" | sed -n -e '1s/^[0-9]*\.[0-9]*\.\([0-9]*\).*/\1/p'`"
-suffix="`echo "$version" | sed -n -e '1s/^[^+]*+\(.*\)/\1/p'`"
+suffix="`echo "$version" | sed -n -e '1s/^[^+~]*[+~]\(.*\)/\1/p'`"
echo "#define OCAML_VERSION_MAJOR $major"
printf '#define OCAML_VERSION_MINOR %d\n' "$minor"
open Printf
open Misc
-open Config
open Cmo_format
(* Command line options to prevent printing approximation,
let no_code = ref false
let no_crc = ref false
+module Magic_number = Misc.Magic_number
+
let input_stringlist ic len =
let get_string_list sect len =
let rec fold s e acc =
(* PR#4949: print in linking order *)
List.iter print_spaced_string (List.rev lib.lib_ccobjs);
printf "\nExtra C options:";
- List.iter print_spaced_string lib.lib_ccopts;
+ List.iter print_spaced_string (List.rev lib.lib_ccopts);
printf "\n";
print_string "Extra dynamically-loaded libraries:";
- List.iter print_spaced_string lib.lib_dllibs;
+ List.iter print_spaced_string (List.rev lib.lib_dllibs);
printf "\n";
List.iter print_cmo_infos lib.lib_units
printf "Extra C object files:";
List.iter print_spaced_string (List.rev lib.lib_ccobjs);
printf "\nExtra C options:";
- List.iter print_spaced_string lib.lib_ccopts;
+ List.iter print_spaced_string (List.rev lib.lib_ccopts);
printf "\n";
List.iter print_cmx_infos lib.lib_units
)
toc
-let read_dyn_header filename ic =
+let find_dyn_offset filename =
let helper = Filename.concat Config.standard_library "objinfo_helper" in
let tempfile = Filename.temp_file "objinfo" ".out" in
- try
- try_finally
- ~always:(fun () -> remove_file tempfile)
+ match
+ Fun.protect
+ ~finally:(fun () -> remove_file tempfile)
(fun () ->
- let rc = Sys.command (sprintf "%s %s > %s"
- (Filename.quote helper)
- (Filename.quote filename)
- tempfile) in
+ let rc =
+ Sys.command
+ (Filename.quote_command helper ~stdout:tempfile [filename])
+ in
if rc <> 0 then failwith "cannot read";
let tc = Scanf.Scanning.from_file tempfile in
- try_finally
- ~always:(fun () -> Scanf.Scanning.close_in tc)
+ Fun.protect
+ ~finally:(fun () -> Scanf.Scanning.close_in tc)
(fun () ->
- let ofs = Scanf.bscanf tc "%Ld" (fun x -> x) in
- LargeFile.seek_in ic ofs;
- Some(input_value ic : dynheader)))
- with Failure _ | Sys_error _ -> None
+ Scanf.bscanf tc "%Ld" (fun x -> x)))
+ with
+ | offset -> Some offset
+ | exception (Failure _ | Sys_error _) -> None
+
+let exit_err msg = print_endline msg; exit 2
+let exit_errf fmt = Printf.ksprintf exit_err fmt
+
+let exit_magic_msg msg =
+ exit_errf
+ "Wrong magic number:\n\
+ this tool only supports object files produced by compiler version\n\
+ \t%s\n\
+ %s"
+ Sys.ocaml_version msg
+
+let exit_magic_error ~expected_kind err =
+ exit_magic_msg Magic_number.(match err with
+ | Parse_error err -> explain_parse_error expected_kind err
+ | Unexpected_error err -> explain_unexpected_error err)
+
+(* assume that 'ic' is already positioned at the right place
+ depending on the format (usually right after the magic number,
+ but Exec and Cmxs differ) *)
+let dump_obj_by_kind filename ic obj_kind =
+ let open Magic_number in
+ match obj_kind with
+ | Cmo ->
+ let cu_pos = input_binary_int ic in
+ seek_in ic cu_pos;
+ let cu = (input_value ic : compilation_unit) in
+ close_in ic;
+ print_cmo_infos cu
+ | Cma ->
+ let toc_pos = input_binary_int ic in
+ seek_in ic toc_pos;
+ let toc = (input_value ic : library) in
+ close_in ic;
+ print_cma_infos toc
+ | Cmi | Cmt ->
+ close_in ic;
+ let cmi, cmt = Cmt_format.read filename in
+ begin match cmi with
+ | None -> ()
+ | Some cmi ->
+ print_cmi_infos cmi.Cmi_format.cmi_name cmi.Cmi_format.cmi_crcs
+ end;
+ begin match cmt with
+ | None -> ()
+ | Some cmt -> print_cmt_infos cmt
+ end
+ | Cmx _config ->
+ let ui = (input_value ic : unit_infos) in
+ let crc = Digest.input ic in
+ close_in ic;
+ print_cmx_infos (ui, crc)
+ | Cmxa _config ->
+ let li = (input_value ic : library_infos) in
+ close_in ic;
+ print_cmxa_infos li
+ | Exec ->
+ (* no assumptions on [ic] position,
+ [dump_byte] will seek at the right place *)
+ dump_byte ic;
+ close_in ic
+ | Cmxs ->
+ (* we assume we are at the offset of the dynamic information,
+ as returned by [find_dyn_offset]. *)
+ let header = (input_value ic : dynheader) in
+ close_in ic;
+ print_cmxs_infos header;
+ | Ast_impl | Ast_intf ->
+ exit_errf "The object file type %S \
+ is currently unsupported by this tool."
+ (human_name_of_kind obj_kind)
let dump_obj filename =
- printf "File %s\n" filename;
- let ic = open_in_bin filename in
- let len_magic_number = String.length cmo_magic_number in
- let magic_number = really_input_string ic len_magic_number in
- if magic_number = cmo_magic_number then begin
- let cu_pos = input_binary_int ic in
- seek_in ic cu_pos;
- let cu = (input_value ic : compilation_unit) in
- close_in ic;
- print_cmo_infos cu
- end else if magic_number = cma_magic_number then begin
- let toc_pos = input_binary_int ic in
- seek_in ic toc_pos;
- let toc = (input_value ic : library) in
- close_in ic;
- print_cma_infos toc
- end else if magic_number = cmi_magic_number ||
- magic_number = cmt_magic_number then begin
- close_in ic;
- let cmi, cmt = Cmt_format.read filename in
- begin match cmi with
- | None -> ()
- | Some cmi ->
- print_cmi_infos cmi.Cmi_format.cmi_name cmi.Cmi_format.cmi_crcs
- end;
- begin match cmt with
- | None -> ()
- | Some cmt -> print_cmt_infos cmt
- end
- end else if magic_number = cmx_magic_number then begin
- let ui = (input_value ic : unit_infos) in
- let crc = Digest.input ic in
- close_in ic;
- print_cmx_infos (ui, crc)
- end else if magic_number = cmxa_magic_number then begin
- let li = (input_value ic : library_infos) in
- close_in ic;
- print_cmxa_infos li
- end else begin
- let pos_trailer = in_channel_length ic - len_magic_number in
+ let open Magic_number in
+ let dump_standard ic =
+ match read_current_info ~expected_kind:None ic with
+ | Error ((Unexpected_error _) as err) ->
+ exit_magic_error ~expected_kind:None err
+ | Ok { kind; version = _ } ->
+ dump_obj_by_kind filename ic kind;
+ Ok ()
+ | Error (Parse_error head_error) ->
+ Error head_error
+ and dump_exec ic =
+ let pos_trailer = in_channel_length ic - Magic_number.magic_length in
let _ = seek_in ic pos_trailer in
- let magic_number = really_input_string ic len_magic_number in
- if magic_number = Config.exec_magic_number then begin
- dump_byte ic;
- close_in ic
- end else if Filename.check_suffix filename ".cmxs" then begin
- flush stdout;
- match read_dyn_header filename ic with
+ let expected_kind = Some Exec in
+ match read_current_info ~expected_kind ic with
+ | Error ((Unexpected_error _) as err) ->
+ exit_magic_error ~expected_kind err
+ | Ok _ ->
+ dump_obj_by_kind filename ic Exec;
+ Ok ()
+ | Error (Parse_error _) ->
+ Error ()
+ and dump_cmxs ic =
+ flush stdout;
+ match find_dyn_offset filename with
| None ->
- printf "Unable to read info on file %s\n" filename;
- exit 2
- | Some header ->
- if header.dynu_magic = Config.cmxs_magic_number then
- print_cmxs_infos header
- else begin
- printf "Wrong magic number\n"; exit 2
- end;
- close_in ic
- end else begin
- printf "Not an OCaml object file\n"; exit 2
- end
- end
+ exit_errf "Unable to read info on %s %s."
+ (human_name_of_kind Cmxs) filename
+ | Some offset ->
+ LargeFile.seek_in ic offset;
+ let header = (input_value ic : dynheader) in
+ let expected_kind = Some Cmxs in
+ match parse header.dynu_magic with
+ | Error err ->
+ exit_magic_error ~expected_kind (Parse_error err)
+ | Ok info ->
+ match check_current Cmxs info with
+ | Error err ->
+ exit_magic_error ~expected_kind (Unexpected_error err)
+ | Ok () ->
+ LargeFile.seek_in ic offset;
+ dump_obj_by_kind filename ic Cmxs;
+ ()
+ in
+ printf "File %s\n" filename;
+ let ic = open_in_bin filename in
+ match dump_standard ic with
+ | Ok () -> ()
+ | Error head_error ->
+ match dump_exec ic with
+ | Ok () -> ()
+ | Error () ->
+ if Filename.check_suffix filename ".cmxs"
+ then dump_cmxs ic
+ else exit_magic_error ~expected_kind:None (Parse_error head_error)
let arg_list = [
"-no-approx", Arg.Set no_approx,
+++ /dev/null
-#!/usr/bin/env bash
-
-#**************************************************************************
-#* *
-#* OCaml *
-#* *
-#* Damien Doligez, Jane Street Group, LLC *
-#* *
-#* Copyright 2015 Institut National de Recherche en Informatique et *
-#* en Automatique. *
-#* *
-#* All rights reserved. This file is distributed under the terms of *
-#* the GNU Lesser General Public License version 2.1, with the *
-#* special exception on linking described in the file LICENSE. *
-#* *
-#**************************************************************************
-
-# Use this script on OCAML_INSTR_FILE files
-
-default_curves=major,minor,coll,dispatch
-
-usage () {
- echo 'usage: ocaml-instr-graph file [options]'
- echo ' options:'
- echo " -d names plot the data for names (default: $default_curves)"
- echo ' -t title set the graph title'
- echo ' -m n clip the values to n (default 1G)'
- echo ' -rt n set the range for times to 0..n'
- echo ' -rn n set the range for counts to 0..n'
- echo ' -from t start at time t'
- echo ' -to t stop at time t'
- echo ' -help display this help message and exit'
-}
-
-datafile=
-curves=,
-title=
-titleset=false
-max=1000000000
-ranget=
-rangen=
-from=0
-to=1e19
-
-while [[ $# > 0 ]]; do
- case $1 in
- -d) curves=$curves$2,; shift 2;;
- -t) title=$2; titleset=true; shift 2;;
- -m) max=$2; shift 2;;
- -rt) ranget="set yrange [0:$2]"; shift 2;;
- -rn) rangen="set y2range [0:$2]"; shift 2;;
- -from) from=$2; shift 2;;
- -to) to=$2; shift 2;;
- -help) usage; exit 0;;
- *) datafile=$1; shift 1;;
- esac
-done
-
-if [[ "$curves" = , ]]; then
- curves=,$default_curves,
-fi
-
-if ! $titleset; then
- title=$datafile
-fi
-
-tmpfile=/tmp/ocaml-instr-graph.$$
-
-rm -f $tmpfile-*
-
-awk -v curves="$curves" -v clip=$max -v tmpfile="$tmpfile" -v from=$from \
- -v to=$to '
- function output (filename){
- time = ($2 - starttime) / 1e9;
- if (time < from || time >= to) return;
- if (index(curves, "," filename ",") != 0){
- gsub (/\//,":",filename);
- if (filename ~ /#/){
- point = $3;
- }else{
- point = ($3 - $2) / 1000;
- }
- if (point > clip) point = clip;
- printf ("%.6f %.3f\n", time, point) >> tmpfile "-" filename;
- }
- }
- BEGIN {starttime = 9e18;}
- $1 != "@@" { next; }
- $2 < starttime { starttime = $2 }
- { output($4); }
-' $datafile
-
-( echo set title \"$title\"
- echo set key left top
- echo set ytics nomirror
- echo 'set format y "%gus"'
- echo "$ranget"
- echo "$rangen"
- echo set y2tics nomirror
- echo 'set format x "%gs"'
- printf "plot "
- for curve in ${curves//,/ }; do
- f=$tmpfile-${curve//\//:}
- if [ -f $f ]; then
- case $f in
- *#) printf "\"%s\" using 1:2 axes x1y2 title '%s', " "$f" \
- "$curve"
- ;;
- *) printf "\"%s\" using 1:2 title '%s', " "$f" "$curve";;
- esac
- fi
- done
- printf "\n"
-) | gnuplot -p
-
-rm -f $tmpfile-*
+++ /dev/null
-#!/bin/awk -f
-
-#**************************************************************************
-#* *
-#* OCaml *
-#* *
-#* Damien Doligez, Jane Street Group, LLC *
-#* *
-#* Copyright 2014 Institut National de Recherche en Informatique et *
-#* en Automatique. *
-#* *
-#* All rights reserved. This file is distributed under the terms of *
-#* the GNU Lesser General Public License version 2.1, with the *
-#* special exception on linking described in the file LICENSE. *
-#* *
-#**************************************************************************
-
-# usage:
-# ocaml-instr-report { file ... }
-# generate a report from the data files (or stdin if no file is given)
-
-function short(n, kind, i, r){
- for (i = 0; i < 5; i++){
- if (n < 1000) break;
- n /= 1000;
- }
- r = sprintf ("%f", n);
- if (index(r, ".") == 3){
- r = substr(r, 1, 2);
- }else{
- r = substr(r, 1, 3);
- }
- return sprintf("%s%s", r, units[kind,i]);
-}
-
-function add(limit){
- lim[nscales] = limit;
- scale["t",nscales] = short(limit, "t");
- scale["n",nscales] = short(limit, "n");
- ++ nscales;
-}
-
-# kind is "t" (for timer) or "n" (for number)
-# events are simply a special kind of timer
-
-BEGIN {
- units["t",0] = "ns";
- units["t",1] = "us";
- units["t",2] = "ms";
- units["t",3] = "s";
- units["t",4] = "ks";
- units["t",5] = "Ms";
-
- units["n",0] = "";
- units["n",1] = "k";
- units["n",2] = "M";
- units["n",3] = "G";
- units["n",4] = "T";
- units["n",5] = "P";
-
- nscales=0;
- add(0);
- for (mul = 100; mul < 10000000000; mul *= 10){
- add(mul);
- add(2.2 * mul);
- add(4.7 * mul);
- }
-}
-
-function store(value, tag) {
- ++ total[tag];
- for (i = 0; i < nscales; i++){
- if (value <= lim[i]){
- ++ bin[tag, lim[i]];
- val[tag, lim[i]] = value;
- return;
- }
- }
- ++ bin[tag, "off-scale"];
- val[tag, "off-scale"] = value;
-}
-
-$1 == "@@" && $4 ~ /@/ { total[$4] += $3; }
-
-$1 == "@@" && $4 ~ /#/ { store($3, $4); }
-
-$1 == "@@" { store($3 - $2, $4); }
-
-function display(n, val, kind, i) {
- graph_width = 35;
-
- if (n > 0){
- for (i = 0; i < log (n) / log (2); i++){
- printf("#");
- }
- if (n == 1){
- printf(" %-6d", n);
- printf ("%-*s", graph_width - 7 - i,
- sprintf("(%s)", short(val, kind)));
- }else{
- printf(" %-*d", graph_width - 1 - i, n);
- }
- }else{
- printf("%*s", graph_width, "");
- }
-}
-
-END {
- n = asorti(total,tags);
- total_alloc = 0;
- for (i = 1; i <= n; i++){
- t = tags[i];
- if (t ~ /^alloc/) total_alloc += total[t];
- }
- for (i = 1; i <= n; i++){
- t = tags[i];
- if (t ~ /#/){
- kind = "n"; # number
- }else if (t ~ /@/){
- kind = "e"; # event
- }else{
- kind = "t"; # timer
- }
- if (kind == "e"){
- printf ("==== %-12s:%9d", t, total[t]);
- if (t ~ /^alloc/){
- cumul += total[t] / total_alloc;
- printf(" (%6.2f%%)", cumul * 100);
- }
- printf ("\n");
- continue;
- }else{
- printf ("==== %s: %d\n", t, total[t]);
- }
- num = bin[t,0];
- found = num;
- if (num == total[t] && kind == "t"){
- /* nothing */
- }else if (num > 0){
- printf (" 0: ");
- display(bin[t,0], val[t, 0], kind);
- printf ("%6.2f%%\n", found * 100 / total[t]);
- }
- for (j = 1; j < nscales; j++){
- if (found == total[t]) break;
- num = bin [t, lim[j]];
- found += num;
- if (found > 0){
- printf ("%5s..%-5s: ", scale[kind,j-1], scale[kind,j]);
- display(num, val[t, lim[j]], kind);
- printf ("%6.2f%%\n", found * 100 / total[t]);
- }
- }
- num = bin[t, "off-scale"];
- if (num != 0){
- printf (" off scale : ");
- display(bin[t, "off-scale"], val[t, "off-scale"]);
- printf ("\n");
- }
- printf ("====\n");
- }
-}
end;
()
+let generate_ml target_filename filename cmt =
+ let (printer, ext) =
+ match cmt.Cmt_format.cmt_annots with
+ | Cmt_format.Implementation typedtree ->
+ (fun ppf -> Pprintast.structure ppf
+ (Untypeast.untype_structure typedtree)),
+ ".ml"
+ | Cmt_format.Interface typedtree ->
+ (fun ppf -> Pprintast.signature ppf
+ (Untypeast.untype_signature typedtree)),
+ ".mli"
+ | _ ->
+ Printf.fprintf stderr "File was generated with an error\n%!";
+ exit 2
+ in
+ let target_filename = match target_filename with
+ None -> Some (filename ^ ext)
+ | Some "-" -> None
+ | Some _ -> target_filename
+ in
+ let oc = match target_filename with
+ None -> None
+ | Some filename -> Some (open_out filename) in
+ let ppf = match oc with
+ None -> Format.std_formatter
+ | Some oc -> Format.formatter_of_out_channel oc in
+ printer ppf;
+ Format.pp_print_flush ppf ();
+ match oc with
+ None -> flush stdout
+ | Some oc -> close_out oc
+
+(* Save cmt information as faked annotations, attached to
+ Location.none, on top of the .annot file. Only when -save-cmt-info is
+ provided to ocaml_cmt.
+*)
+let record_cmt_info cmt =
+ let location_none = {
+ Location.none with Location.loc_ghost = false }
+ in
+ let location_file file = {
+ Location.none with
+ Location.loc_start = {
+ Location.none.Location.loc_start with
+ Lexing.pos_fname = file }}
+ in
+ let record_info name value =
+ let ident = Printf.sprintf ".%s" name in
+ Stypes.record (Stypes.An_ident (location_none, ident,
+ Annot.Idef (location_file value)))
+ in
+ let open Cmt_format in
+ (* record in reverse order to get them in correct order... *)
+ List.iter (fun dir -> record_info "include" dir) (List.rev cmt.cmt_loadpath);
+ record_info "chdir" cmt.cmt_builddir;
+ (match cmt.cmt_sourcefile with
+ None -> () | Some file -> record_info "source" file)
+
let main () =
Clflags.annotations := true;
Filename.check_suffix filename ".cmt" ||
Filename.check_suffix filename ".cmti"
then begin
+ let open Cmt_format in
Compmisc.init_path ();
- let cmt = Cmt_format.read_cmt filename in
- if !gen_annot then
- Cmt2annot.gen_annot ~save_cmt_info: !save_cmt_info
- !target_filename filename cmt;
- if !gen_ml then Cmt2annot.gen_ml !target_filename filename cmt;
+ let cmt = read_cmt filename in
+ if !gen_annot then begin
+ if !save_cmt_info then record_cmt_info cmt;
+ let target_filename =
+ match !target_filename with
+ | None -> Some (filename ^ ".annot")
+ | Some "-" -> None
+ | Some _ as x -> x
+ in
+ Envaux.reset_cache ();
+ List.iter Load_path.add_dir (List.rev cmt.cmt_loadpath);
+ Cmt2annot.gen_annot target_filename
+ ~sourcefile:cmt.cmt_sourcefile
+ ~use_summaries:cmt.cmt_use_summaries
+ cmt.cmt_annots
+ end;
+ if !gen_ml then generate_ml !target_filename filename cmt;
if !print_info_arg || not (!gen_ml || !gen_annot) then print_info cmt;
end else begin
Printf.fprintf stderr
## A few days in advance
-Send a mail on caml-devel to warn Gabriel (to make a pass on Changes)
-and the OCamlLabs folks (for OPAM testing).
+Send a mail on caml-devel to warn Gabriel (to make a pass on Changes;
+see the "Changes curation" appendix for more details) and the
+OCamlLabs folks (for OPAM testing).
## 0: release environment setup
# 4.07.0+dev8-2018-06-19 => 4.07.0+dev9-2018-06-26
# for production releases: check and change the Changes header
# (remove "next version" and add a date)
-./autogen
+make -B configure
git commit -a -m "last commit before tagging $VERSION"
# update VERSION with the new release; for example,
# Update ocaml-variants.opam with new version.
# Update \year in manual/manual/macros.hva
rm -r autom4te.cache
-./autogen
+make -B configure
make coreboot -j5
make coreboot -j5 # must say "Fixpoint reached, bootstrap succeeded."
git commit -m "release $VERSION" -a
# 4.07.0+rc2 => 4.07.0+dev10-2018-06-26
# Revert ocaml-variants.opam to its "trunk" version.
rm -r autom4te.cache
-./autogen
+make -B configure
git commit -m "increment version number after tagging $VERSION" VERSION configure ocaml-variants.opam
git push
git push --tags
```
+## 5-bis: Alternative for branching
+
+This needs to be more tested, tread with care.
+```
+# at this point, the VERSION file contains N+devD
+# increment it into N+dev(D+1); for example,
+# 4.07.0+dev0-2018-06-19 => 4.07.0+dev1-2018-06-26
+# Rename the "Working version" header in Changes
+# to "OCaml $BRANCH"
+make -B configure
+git commit -a -m "last commit before branching $BRANCH"
+git branch $BRANCH
+
+# update VERSION with the new future branch,
+# 4.07.0+dev1-2018-06-26 => 4.08.0+dev0-2018-06-30
+# Update ocaml-variants.opam with new version.
+make -B configure
+# Add a "Working version" section" to Changes
+# Add common subsections in Changes, see Changelog.
+git commit -m "first commit after branching $VERSION" -a
+git push
+
+# Switch to the new branch
+git checkout $VERSION
+# increment VERSION, for instance
+# 4.07.0+dev1-2018-06-26 => 4.07.0+dev2-2018-06-30
+make -B configure
+git commit -m "first commit on branch $VERSION" -a
+git push $VERSION
+```
+
+Adjust github branch settings:
+
+Go to
+ https://github.com/ocaml/ocaml/settings/branches
+and add a rule for protecting the new branch
+(copy the rights from the previous version)
+
## 5.1: create the release on github (only for a production release)
open https://github.com/ocaml/ocaml/releases
# for a minor release, the description is:
Bug fixes. See [detailed list of changes](https://github.com/ocaml/ocaml/blob/$MAJOR.$MINOR/Changes).
+## 5.3: Inria CI (for a new release branch)
+
+Add the new release branch to the Inria CI list.
+Remove the oldest branch from this list.
+
+## 5.4 new badge in README.adoc (for a new release branch)
+
+Add a badge for the new branch in README.adoc.
+Remove any badge that tracks a version older than Debian stable.
+
## 6: create OPAM packages
"url" section of the opam files. Use opam-lint before sending the pull
request.
+## 6.1 Update OPAM dev packages after branching
+
+Create a new ocaml/ocaml.$NEXT/opam file.
+Copy the opam dev files from ocaml-variants/ocaml-variants.$VERSION+trunk*
+into ocaml-variants/ocaml-variants.$NEXT+trunk+* .
+Update the version in those opam files.
+
+Update the synopsis and "src" field in the opam $VERSION packages.
+The "src" field should point to
+ src: "https://github.com/ocaml/ocaml/archive/$VERSION.tar.gz"
+The synopsis should be "latest $VERSION development(,...)".
+
## 7: build the release archives
```
-# Announces
+# Appendix
## Announcing a production release:
-- Damien Doligez for the OCaml team.
```
+
+## Changelog template for a new version
+
+A list of common subsection for the "Changes" file:
+
+```
+### Language features
+
+### Runtime system:
+
+### Code generation and optimizations:
+
+### Standard library:
+
+### Other libraries:
+
+### Tools:
+
+### Manual and documentation:
+
+### Compiler user-interface and warnings:
+
+### Internal/compiler-libs changes:
+
+### Build system:
+
+### Bug fixes:
+```
+
+
+## Changes curation
+
+Here is the process that Gabriel uses to curate the Changes entries of
+a release in preparation. Feel free to take care of it if you wish.
+
+(In theory it would be possible to maintain the Changes in excellent
+ shape so that no curation would be necessary. In practice it is less
+ work and less friction to tolerate imperfect Changes entries, and
+ curate them before the release.)
+
+### Synchronizing the trunk Changes with release branches
+
+The Changes entries of a release branch or past release should be
+exactly included in the trunk Changes, in the section of this release
+(or release branch). Use an interactive diffing tool (for example
+"meld") to compare and synchronize the Changes files of trunk and
+release branches.
+
+Here are typical forms of divergence and their usual solutions:
+
+- A change entry is present in a different section in two branches.
+ (Typically: in the XX.YY section of the XX.YY release branch,
+ but in the trunk section of the trunk branch.)
+
+ This usually happens when the PR is written for a given branch
+ first, and then cherry-picked in an older maintenance branch, but
+ the cherry-picker forgets to move the Change entry in the first
+ branch.
+
+ Fix: ensure that the entry is in the same section on all branches,
+ by putting it in the "smallest" version -- assuming that all bigger
+ versions also contain this cange.
+
+- A change entry is present in a given section, but the change is not
+ present in the corresponding release branch.
+
+ There are two common causes for this with radically different solutions:
+
+ + If a PR is merged a long time after they were submitted, the merge
+ may put their Changes entry in the section of an older release,
+ while it should go in trunk.
+
+ Fix: in trunk, move the entry to the trunk section.
+
+ + Sometimes the author of a PR against trunk intends it to be
+ cherry-picked in an older release branch, and places it in the
+ corresponding Changes entry, but we forget to cherry-pick.
+
+ Fix: cherry-pick the PR in the appropriate branch.
+
+ Reading the PR discussion is often enough to distinguish between the
+ two cases, but one should be careful before cherry-picking in
+ a branch (for an active release branch, check with the release
+ manager(s)).
+
+Figuring out the status of a given Changes entry often requires
+checking the git log for trunk and branches. Grepping for the PR
+number often suffices (note: when you cherry-pick a PR in a release
+branch, please target the merge commit to ensure the PR number is
+present in the log), or parts of the commit message text.
+
+### Ensure each entry is in the appropriate section
+
+(of course)
+
+### Fill more details in unclear Changes entries
+
+Expert users want to learn about the changes in the new release. We
+want to avoid forcing them to read the tortuous PR discussion, by
+giving enough details in the Changes entry.
+
+In particular, for language changes, showing a small example of
+concrete syntax of the new feature is very useful, and giving a few
+words of explanations helps.
+
+Compare for example
+
+ - #8820: quoted string extensions
+ (Gabriel Radanne, Leo White and Gabriel Scherer,
+ request by Bikal Lem)
+
+with
+
+ - #8820: quoted extensions: {%foo|...|} is lighter syntax for
+ [%foo {||}], and {%foo bar|...|bar} for [%foo {bar|...|bar}].
+ (Gabriel Radanne, Leo White and Gabriel Scherer,
+ request by Bikal Lem)
+
+This is also important for changes that break compatibility; users
+will scrutinize them with more care, so please give clear information on
+what breaks and, possibly, recommended update methods.
+
+Having enough details is also useful when you will grep the Changes
+later to know when a given change was introduced (knowing what to grep
+can be difficult).
+
+### Ordering of Changes entries
+
+In the past, we would order Changes entries numerically (this would
+also correspond to a chronological order). Since 4.09 Gabriel is
+trying to order them by importance (being an exciting/notable feature
+for a large number of users). What is the best ordering of sections,
+and the best entry ordering within a section, to put the most
+important changes first? This is guesswork of course, and we commonly
+have a long tail of "not so important PRs" in each section which don't
+need to be ordered with respect to each other -- one may break two
+lines just before this long tail.
+
+The ordering of sections depends on the nature of the changes within
+the release; some releases have an exciting "Runtime" section, many
+release don't. Usually "Language features" is among the first, and
+"Bug fixes" is the very last (who cares about bugs, right?).
+
+If some entries feel very anecdotal, consider moving them to the Bug
+Fixes section.
else O.field bucket 0
in
let name = (O.obj(O.field slot 0) : string) in
- let lid = Longident.parse name in
try
(* Attempt to recover the constructor description for the exn
from its name *)
+ let lid =
+ try Parse.longident (Lexing.from_string name) with
+ (* The syntactic class for extension constructor names
+ is an extended form of constructor "Longident.t"s
+ that also includes module application (e.g [F(X).A]) *)
+ | Syntaxerr.Error _ | Lexer.Error _ -> raise Not_found in
let cstr = Env.find_constructor_by_name lid env in
let path =
match cstr.cstr_tag with
(* Load commands from a file *)
let dir_use ppf name = ignore(Opttoploop.use_file ppf name)
+let dir_use_output ppf name = ignore(Opttoploop.use_output ppf name)
let _ = Hashtbl.add directive_table "use" (Directive_string (dir_use std_out))
+let _ = Hashtbl.add directive_table "use_output"
+ (Directive_string (dir_use_output std_out))
(* Install, remove a printer *)
val dir_cd : string -> unit
val dir_load : formatter -> string -> unit
val dir_use : formatter -> string -> unit
+val dir_use_output : formatter -> string -> unit
val dir_install_printer : formatter -> Longident.t -> unit
val dir_remove_printer : formatter -> Longident.t -> unit
let glb, pos = toplevel_value id in
let glob =
Lprim (Pfield pos,
- [Lprim (Pgetglobal glb, [], Location.none)],
- Location.none)
+ [Lprim (Pgetglobal glb, [], Loc_unknown)],
+ Loc_unknown)
in
Llet(Strict, Pgenval, id, glob, l)
) (free_variables lam) lam
let (str, sg, names, newenv) = Typemod.type_toplevel_phrase oldenv sstr in
if !Clflags.dump_typedtree then Printtyped.implementation ppf str;
let sg' = Typemod.Signature_names.simplify newenv names sg in
- (* Why is this done? *)
- ignore (Includemod.signatures oldenv sg sg');
+ ignore (Includemod.signatures oldenv ~mark:Mark_positive sg sg');
Typecore.force_delayed_checks ();
let module_ident, res, required_globals, size =
if Config.flambda then
| Result _ ->
if Config.flambda then
(* CR-someday trefis: *)
- ()
+ Env.register_import_as_opaque (Ident.name module_ident)
else
Compilenv.record_global_approx_toplevel ();
if print_outcome then
if !Clflags.dump_source then Pprintast.top_phrase ppf phr;
phr
-let use_file ppf wrap_mod name =
- try
- let (filename, ic, must_close) =
- if name = "" then
- ("(stdin)", stdin, false)
- else begin
- let filename = Load_path.find name in
- let ic = open_in_bin filename in
- (filename, ic, true)
- end
- in
- let lb = Lexing.from_channel ic in
- Location.init lb filename;
- (* Skip initial #! line if any *)
- Lexer.skip_hash_bang lb;
- let success =
- protect_refs [ R (Location.input_name, filename) ] (fun () ->
- try
- List.iter
- (fun ph ->
- let ph = preprocess_phrase ppf ph in
- if not (execute_phrase !use_print_results ppf ph) then raise Exit)
- (if wrap_mod then
- parse_mod_use_file name lb
- else
- !parse_use_file lb);
- true
- with
- | Exit -> false
- | Sys.Break -> fprintf ppf "Interrupted.@."; false
- | x -> Location.report_exception ppf x; false) in
- if must_close then close_in ic;
- success
- with Not_found -> fprintf ppf "Cannot find file %s.@." name; false
-
-let mod_use_file ppf name = use_file ppf true name
-let use_file ppf name = use_file ppf false name
+let use_channel ppf ~wrap_in_module ic name filename =
+ let lb = Lexing.from_channel ic in
+ Location.init lb filename;
+ (* Skip initial #! line if any *)
+ Lexer.skip_hash_bang lb;
+ let success =
+ protect_refs [ R (Location.input_name, filename) ] (fun () ->
+ try
+ List.iter
+ (fun ph ->
+ let ph = preprocess_phrase ppf ph in
+ if not (execute_phrase !use_print_results ppf ph) then raise Exit)
+ (if wrap_in_module then
+ parse_mod_use_file name lb
+ else
+ !parse_use_file lb);
+ true
+ with
+ | Exit -> false
+ | Sys.Break -> fprintf ppf "Interrupted.@."; false
+ | x -> Location.report_exception ppf x; false) in
+ success
+
+let use_output ppf command =
+ let fn = Filename.temp_file "ocaml" "_toploop.ml" in
+ Misc.try_finally ~always:(fun () ->
+ try Sys.remove fn with Sys_error _ -> ())
+ (fun () ->
+ match
+ Printf.ksprintf Sys.command "%s > %s"
+ command
+ (Filename.quote fn)
+ with
+ | 0 ->
+ let ic = open_in_bin fn in
+ Misc.try_finally ~always:(fun () -> close_in ic)
+ (fun () ->
+ use_channel ppf ~wrap_in_module:false ic "" "(command-output)")
+ | n ->
+ fprintf ppf "Command exited with code %d.@." n;
+ false)
+
+let use_file ppf ~wrap_in_module name =
+ match name with
+ | "" ->
+ use_channel ppf ~wrap_in_module stdin name "(stdin)"
+ | _ ->
+ match Load_path.find name with
+ | filename ->
+ let ic = open_in_bin filename in
+ Misc.try_finally ~always:(fun () -> close_in ic)
+ (fun () -> use_channel ppf ~wrap_in_module ic name filename)
+ | exception Not_found ->
+ fprintf ppf "Cannot find file %s.@." name;
+ false
+
+let mod_use_file ppf name =
+ use_file ppf ~wrap_in_module:true name
+let use_file ppf name =
+ use_file ppf ~wrap_in_module:false name
let use_silently ppf name =
protect_refs [ R (use_print_results, false) ] (fun () -> use_file ppf name)
(* Preprocess the given toplevel phrase using regular and ppx
preprocessors. Return the updated phrase. *)
val use_file : formatter -> string -> bool
+val use_output : formatter -> string -> bool
val use_silently : formatter -> string -> bool
val mod_use_file : formatter -> string -> bool
(* Read and execute commands from a file.
let check_consistency ppf filename cu =
try Env.import_crcs ~source:filename cu.cu_imports
- with Persistent_env.Consistbl.Inconsistency(name, user, auth) ->
+ with Persistent_env.Consistbl.Inconsistency {
+ unit_name = name;
+ inconsistent_source = user;
+ original_source = auth;
+ } ->
fprintf ppf "@[<hv 0>The files %s@ and %s@ \
disagree over interface %s@]@."
user auth name;
(* Load commands from a file *)
let dir_use ppf name = ignore(Toploop.use_file ppf name)
+let dir_use_output ppf name = ignore(Toploop.use_output ppf name)
let dir_mod_use ppf name = ignore(Toploop.mod_use_file ppf name)
let _ = add_directive "use" (Directive_string (dir_use std_out))
doc = "Read, compile and execute source phrases from the given file.";
}
+let _ = add_directive "use_output" (Directive_string (dir_use_output std_out))
+ {
+ section = section_run;
+ doc = "Execute a command and read, compile and execute source phrases \
+ from its output.";
+ }
+
let _ = add_directive "mod_use" (Directive_string (dir_mod_use std_out))
{
section = section_run;
wraps the contents in a module.";
}
-
(* Install, remove a printer *)
let filter_arrow ty =
)
"Print the signature of the corresponding type constructor."
+(* Each registered show_prim function is called in turn
+ * and any output produced is sent to std_out.
+ * Two show_prim functions are needed for constructors,
+ * one for exception constructors and another for
+ * non-exception constructors (normal and extensible variants). *)
+let is_exception_constructor env type_expr =
+ Ctype.equal env true [type_expr] [Predef.type_exn]
+
+let is_extension_constructor = function
+ | Cstr_extension _ -> true
+ | _ -> false
+
+let () =
+ (* This show_prim function will only show constructor types
+ * that are not also exception types. *)
+ reg_show_prim "show_constructor"
+ (fun env loc id lid ->
+ let desc = Env.lookup_constructor ~loc Env.Positive lid env in
+ if is_exception_constructor env desc.cstr_res then
+ raise Not_found;
+ let path =
+ match Ctype.repr desc.cstr_res with
+ | {desc=Tconstr(path, _, _)} -> path
+ | _ -> raise Not_found
+ in
+ let type_decl = Env.find_type path env in
+ if is_extension_constructor desc.cstr_tag then
+ let ret_type =
+ if desc.cstr_generalized then Some desc.cstr_res
+ else None
+ in
+ let ext =
+ { ext_type_path = path;
+ ext_type_params = type_decl.type_params;
+ ext_args = Cstr_tuple desc.cstr_args;
+ ext_ret_type = ret_type;
+ ext_private = Asttypes.Public;
+ ext_loc = desc.cstr_loc;
+ ext_attributes = desc.cstr_attributes;
+ ext_uid = desc.cstr_uid; }
+ in
+ [Sig_typext (id, ext, Text_first, Exported)]
+ else
+ (* make up a fake Ident.t as type_decl : Types.type_declaration
+ * does not have an Ident.t yet. Ident.create_presistent is a
+ * good choice because it has no side-effects.
+ * *)
+ let type_id = Ident.create_persistent (Path.name path) in
+ [ Sig_type (type_id, type_decl, Trec_first, Exported) ]
+ )
+ "Print the signature of the corresponding value constructor."
+
let () =
reg_show_prim "show_exception"
(fun env loc id lid ->
let desc = Env.lookup_constructor ~loc Env.Positive lid env in
- if not (Ctype.equal env true [desc.cstr_res] [Predef.type_exn]) then
+ if not (is_exception_constructor env desc.cstr_res) then
raise Not_found;
let ret_type =
if desc.cstr_generalized then Some Predef.type_exn
ext_args = Cstr_tuple desc.cstr_args;
ext_ret_type = ret_type;
ext_private = Asttypes.Public;
- Types.ext_loc = desc.cstr_loc;
- Types.ext_attributes = desc.cstr_attributes; }
+ ext_loc = desc.cstr_loc;
+ ext_attributes = desc.cstr_attributes;
+ ext_uid = desc.cstr_uid;
+ }
in
[Sig_typext (id, ext, Text_exception, Exported)]
)
val dir_cd : string -> unit
val dir_load : formatter -> string -> unit
val dir_use : formatter -> string -> unit
+val dir_use_output : formatter -> string -> unit
val dir_install_printer : formatter -> Longident.t -> unit
val dir_remove_printer : formatter -> Longident.t -> unit
val dir_trace : formatter -> Longident.t -> unit
let (str, sg, sn, newenv) = Typemod.type_toplevel_phrase oldenv sstr in
if !Clflags.dump_typedtree then Printtyped.implementation ppf str;
let sg' = Typemod.Signature_names.simplify newenv sn sg in
- ignore (Includemod.signatures oldenv sg sg');
+ ignore (Includemod.signatures ~mark:Mark_positive oldenv sg sg');
Typecore.force_delayed_checks ();
let lam = Translmod.transl_toplevel_definition str in
Warnings.check_fatal ();
if !Clflags.dump_source then Pprintast.top_phrase ppf phr;
phr
-let use_file ppf wrap_mod name =
- try
- let (filename, ic, must_close) =
- if name = "" then
- ("(stdin)", stdin, false)
- else begin
- let filename = Load_path.find name in
- let ic = open_in_bin filename in
- (filename, ic, true)
- end
- in
- let lb = Lexing.from_channel ic in
- Warnings.reset_fatal ();
- Location.init lb filename;
- (* Skip initial #! line if any *)
- Lexer.skip_hash_bang lb;
- let success =
- protect_refs [ R (Location.input_name, filename);
- R (Location.input_lexbuf, Some lb); ]
- (fun () ->
- try
- List.iter
- (fun ph ->
- let ph = preprocess_phrase ppf ph in
- if not (execute_phrase !use_print_results ppf ph) then raise Exit)
- (if wrap_mod then
- parse_mod_use_file name lb
- else
- !parse_use_file lb);
- true
- with
- | Exit -> false
- | Sys.Break -> fprintf ppf "Interrupted.@."; false
- | x -> Location.report_exception ppf x; false) in
- if must_close then close_in ic;
- success
- with Not_found -> fprintf ppf "Cannot find file %s.@." name; false
-
-let mod_use_file ppf name = use_file ppf true name
-let use_file ppf name = use_file ppf false name
+let use_channel ppf ~wrap_in_module ic name filename =
+ let lb = Lexing.from_channel ic in
+ Warnings.reset_fatal ();
+ Location.init lb filename;
+ (* Skip initial #! line if any *)
+ Lexer.skip_hash_bang lb;
+ protect_refs [ R (Location.input_name, filename);
+ R (Location.input_lexbuf, Some lb); ]
+ (fun () ->
+ try
+ List.iter
+ (fun ph ->
+ let ph = preprocess_phrase ppf ph in
+ if not (execute_phrase !use_print_results ppf ph) then raise Exit)
+ (if wrap_in_module then
+ parse_mod_use_file name lb
+ else
+ !parse_use_file lb);
+ true
+ with
+ | Exit -> false
+ | Sys.Break -> fprintf ppf "Interrupted.@."; false
+ | x -> Location.report_exception ppf x; false)
+
+let use_output ppf command =
+ let fn = Filename.temp_file "ocaml" "_toploop.ml" in
+ Misc.try_finally ~always:(fun () ->
+ try Sys.remove fn with Sys_error _ -> ())
+ (fun () ->
+ match
+ Printf.ksprintf Sys.command "%s > %s"
+ command
+ (Filename.quote fn)
+ with
+ | 0 ->
+ let ic = open_in_bin fn in
+ Misc.try_finally ~always:(fun () -> close_in ic)
+ (fun () ->
+ use_channel ppf ~wrap_in_module:false ic "" "(command-output)")
+ | n ->
+ fprintf ppf "Command exited with code %d.@." n;
+ false)
+
+let use_file ppf ~wrap_in_module name =
+ match name with
+ | "" ->
+ use_channel ppf ~wrap_in_module stdin name "(stdin)"
+ | _ ->
+ match Load_path.find name with
+ | filename ->
+ let ic = open_in_bin filename in
+ Misc.try_finally ~always:(fun () -> close_in ic)
+ (fun () -> use_channel ppf ~wrap_in_module ic name filename)
+ | exception Not_found ->
+ fprintf ppf "Cannot find file %s.@." name;
+ false
+
+let mod_use_file ppf name =
+ use_file ppf ~wrap_in_module:true name
+let use_file ppf name =
+ use_file ppf ~wrap_in_module:false name
let use_silently ppf name =
protect_refs [ R (use_print_results, false) ] (fun () -> use_file ppf name)
(* Preprocess the given toplevel phrase using regular and ppx
preprocessors. Return the updated phrase. *)
val use_file : formatter -> string -> bool
+val use_output : formatter -> string -> bool
val use_silently : formatter -> string -> bool
val mod_use_file : formatter -> string -> bool
(* Read and execute commands from a file.
- Track "string literals" in the type-checker, which often act as
magic "internal" names which should be avoided.
-- Get rid of -annot.
- (see Nicolas' PR)
-
- Consider storing warning settings (+other context) as part of `Env.t`?
- Parse attributes understood (e.g. the deprecated attribute) by the
| Optional s -> "?" ^ s
let rec extract_label_aux hd l = function
- [] -> raise Not_found
+ | [] -> None
| (l',t as p) :: ls ->
- if label_name l' = l then (l', t, List.rev hd, ls)
- else extract_label_aux (p::hd) l ls
+ if label_name l' = l then
+ Some (l', t, hd <> [], List.rev_append hd ls)
+ else
+ extract_label_aux (p::hd) l ls
let extract_label l ls = extract_label_aux [] l ls
val extract_label :
label -> (arg_label * 'a) list ->
- arg_label * 'a * (arg_label * 'a) list * (arg_label * 'a) list
- (* actual label, value, before list, after list *)
+ (arg_label * 'a * bool * (arg_label * 'a) list) option
+(* actual label,
+ value,
+ whether (label, value) was at the head of the list,
+ list without the extracted (label, value) *)
(**** Utilities for backtracking ****)
--- /dev/null
+(**************************************************************************)
+(* *)
+(* OCaml *)
+(* *)
+(* Fabrice Le Fessant, INRIA Saclay *)
+(* *)
+(* Copyright 2012 Institut National de Recherche en Informatique et *)
+(* en Automatique. *)
+(* *)
+(* All rights reserved. This file is distributed under the terms of *)
+(* the GNU Lesser General Public License version 2.1, with the *)
+(* special exception on linking described in the file LICENSE. *)
+(* *)
+(**************************************************************************)
+
+(* Generate an .annot file from a .cmt file. *)
+
+open Asttypes
+open Typedtree
+open Tast_iterator
+
+let variables_iterator scope =
+ let super = default_iterator in
+ let pat sub (type k) (p : k general_pattern) =
+ begin match p.pat_desc with
+ | Tpat_var (id, _) | Tpat_alias (_, id, _) ->
+ Stypes.record (Stypes.An_ident (p.pat_loc,
+ Ident.name id,
+ Annot.Idef scope))
+ | _ -> ()
+ end;
+ super.pat sub p
+ in
+ {super with pat}
+
+let bind_variables scope =
+ let iter = variables_iterator scope in
+ fun p -> iter.pat iter p
+
+let bind_bindings scope bindings =
+ let o = bind_variables scope in
+ List.iter (fun x -> o x.vb_pat) bindings
+
+let bind_cases l =
+ List.iter
+ (fun {c_lhs; c_guard; c_rhs} ->
+ let loc =
+ let open Location in
+ match c_guard with
+ | None -> c_rhs.exp_loc
+ | Some g -> {c_rhs.exp_loc with loc_start=g.exp_loc.loc_start}
+ in
+ bind_variables loc c_lhs
+ )
+ l
+
+let record_module_binding scope mb =
+ Stypes.record (Stypes.An_ident
+ (mb.mb_name.loc,
+ Option.value mb.mb_name.txt ~default:"_",
+ Annot.Idef scope))
+
+let rec iterator ~scope rebuild_env =
+ let super = default_iterator in
+ let class_expr sub node =
+ Stypes.record (Stypes.Ti_class node);
+ super.class_expr sub node
+
+ and module_expr _sub node =
+ Stypes.record (Stypes.Ti_mod node);
+ super.module_expr (iterator ~scope:node.mod_loc rebuild_env) node
+
+ and expr sub exp =
+ begin match exp.exp_desc with
+ | Texp_ident (path, _, _) ->
+ let full_name = Path.name ~paren:Oprint.parenthesized_ident path in
+ let env =
+ if rebuild_env then
+ Env.env_of_only_summary Envaux.env_from_summary exp.exp_env
+ else
+ exp.exp_env
+ in
+ let annot =
+ try
+ let desc = Env.find_value path env in
+ let dloc = desc.Types.val_loc in
+ if dloc.Location.loc_ghost then Annot.Iref_external
+ else Annot.Iref_internal dloc
+ with Not_found ->
+ Annot.Iref_external
+ in
+ Stypes.record
+ (Stypes.An_ident (exp.exp_loc, full_name , annot))
+ | Texp_let (Recursive, bindings, _) ->
+ bind_bindings exp.exp_loc bindings
+ | Texp_let (Nonrecursive, bindings, body) ->
+ bind_bindings body.exp_loc bindings
+ | Texp_match (_, f1, _) ->
+ bind_cases f1
+ | Texp_function { cases = f; }
+ | Texp_try (_, f) ->
+ bind_cases f
+ | Texp_letmodule (_, modname, _, _, body ) ->
+ Stypes.record (Stypes.An_ident
+ (modname.loc,Option.value ~default:"_" modname.txt,
+ Annot.Idef body.exp_loc))
+ | _ -> ()
+ end;
+ Stypes.record (Stypes.Ti_expr exp);
+ super.expr sub exp
+
+ and pat sub (type k) (p : k general_pattern) =
+ Stypes.record (Stypes.Ti_pat (classify_pattern p, p));
+ super.pat sub p
+ in
+
+ let structure_item_rem sub str rem =
+ let open Location in
+ let loc = str.str_loc in
+ begin match str.str_desc with
+ | Tstr_value (rec_flag, bindings) ->
+ let doit loc_start = bind_bindings {scope with loc_start} bindings in
+ begin match rec_flag, rem with
+ | Recursive, _ -> doit loc.loc_start
+ | Nonrecursive, [] -> doit loc.loc_end
+ | Nonrecursive, {str_loc = loc2} :: _ -> doit loc2.loc_start
+ end
+ | Tstr_module mb ->
+ record_module_binding
+ { scope with Location.loc_start = loc.loc_end } mb
+ | Tstr_recmodule mbs ->
+ List.iter (record_module_binding
+ { scope with Location.loc_start = loc.loc_start }) mbs
+ | _ ->
+ ()
+ end;
+ Stypes.record_phrase loc;
+ super.structure_item sub str
+ in
+ let structure_item sub s =
+ (* This will be used for Partial_structure_item.
+ We don't have here the location of the "next" item,
+ this will give a slightly different scope for the non-recursive
+ binding case. *)
+ structure_item_rem sub s []
+ in
+ let structure sub l =
+ let rec loop = function
+ | str :: rem -> structure_item_rem sub str rem; loop rem
+ | [] -> ()
+ in
+ loop l.str_items
+ in
+ {super with class_expr; module_expr; expr; pat; structure_item; structure}
+
+let binary_part iter x =
+ let open Cmt_format in
+ match x with
+ | Partial_structure x -> iter.structure iter x
+ | Partial_structure_item x -> iter.structure_item iter x
+ | Partial_expression x -> iter.expr iter x
+ | Partial_pattern (_, x) -> iter.pat iter x
+ | Partial_class_expr x -> iter.class_expr iter x
+ | Partial_signature x -> iter.signature iter x
+ | Partial_signature_item x -> iter.signature_item iter x
+ | Partial_module_type x -> iter.module_type iter x
+
+let gen_annot target_filename ~sourcefile ~use_summaries annots =
+ let open Cmt_format in
+ let scope =
+ match sourcefile with
+ | None -> Location.none
+ | Some s -> Location.in_file s
+ in
+ let iter = iterator ~scope use_summaries in
+ match annots with
+ | Implementation typedtree ->
+ iter.structure iter typedtree;
+ Stypes.dump target_filename
+ | Partial_implementation parts ->
+ Array.iter (binary_part iter) parts;
+ Stypes.dump target_filename
+ | Interface _ | Packed _ | Partial_interface _ ->
+ ()
let free_variables = ref []
let really_closed = ref None
+(* [free_vars_rec] collects the variables of the input type
+ expression into the [free_variables] reference. It is used for
+ several different things in the type-checker, with the following
+ bells and whistles:
+ - If [really_closed] is Some typing environment, types in the environment
+ are expanded to check whether the apparently-free variable would vanish
+ during expansion.
+ - We collect both type variables and row variables, paired with a boolean
+ that is [true] if we have a row variable.
+ - We do not count "virtual" free variables -- free variables stored in
+ the abbreviation of an object type that has been expanded (we store
+ the abbreviations for use when displaying the type).
+
+ The functions [free_vars] and [free_variables] below receive
+ a typing environment as an optional [?env] parameter and
+ set [really_closed] accordingly.
+ [free_vars] returns a [(variable * bool) list], while
+ [free_variables] drops the type/row information
+ and only returns a [variable list].
+ *)
let rec free_vars_rec real ty =
let ty = repr ty in
if ty.level >= lowest_level then begin
type_private = Public;
type_manifest = manifest;
type_variance = [];
+ type_separability = [];
type_is_newtype = true;
type_expansion_scope = expansion_scope;
type_loc = Location.none;
type_attributes = [];
type_immediate = Unknown;
type_unboxed = unboxed_false_default_false;
+ type_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
}
let existential_name cstr ty = match repr ty with
match ty.desc with
Tarrow _ | Ttuple _ | Tvariant _ | Tconstr _ | Tobject _ | Tpackage _ ->
(ty,(t,bound)) :: visited
- | _ -> visited in
+ | Tvar _ | Tfield _ | Tnil | Tpoly _ | Tunivar _ | Tlink _ | Tsubst _ ->
+ visited
+ in
let copy_rec = copy_sep cleanup_scope fixed free bound visited in
t.desc <-
begin match ty.desc with
(* We shall really check the level on the row variable *)
let keep = is_Tvar more && more.level <> generic_level in
let more' = copy_rec more in
- let fixed' = fixed && is_Tvar (repr more') in
+ let fixed' = fixed && (is_Tvar more || is_Tunivar more) in
let row = copy_row copy_rec fixed' row keep more' in
Tvariant row
| Tpoly (t1, tl) ->
let td = Env.find_type p env in
List.iter2
(fun t v ->
- if Variance.(mem May_pos v || mem May_neg v)
- then occur_rec bound t)
+ (* The null variance only occurs in type abbreviations and
+ corresponds to type variables that do not occur in the
+ definition (expansion would erase them completely).
+ The type-checker consistently ignores type expressions
+ in this position. Physical expansion, as done in `occur`,
+ would be costly here, since we need to check inside
+ object and variant types too. *)
+ if not Variance.(eq v null) then occur_rec bound t)
tl td.type_variance
with Not_found ->
List.iter (occur_rec bound) tl
begin try
let td = Env.find_type p env in
List.iter2
- (fun t v ->
- if Variance.(mem May_pos v || mem May_neg v) then occur t)
+ (* see occur_univar *)
+ (fun t v -> if not Variance.(eq v null) then occur t)
tl td.type_variance
with Not_found ->
List.iter occur tl
let univar_pairs = ref []
-(* assumption: [ty] is fully generalized. *)
-let reify_univars ty =
- let rec subst_univar scope vars ty =
+(**** Instantiate a generic type into a poly type ***)
+
+let polyfy env ty vars =
+ let subst_univar scope ty =
let ty = repr ty in
- if ty.level >= lowest_level then begin
- ty.level <- pivot_level - ty.level;
- match ty.desc with
- | Tvar name ->
- For_copy.save_desc scope ty ty.desc;
- let t = newty2 ty.level (Tunivar name) in
- vars := t :: !vars;
- ty.desc <- Tsubst t
- | _ ->
- iter_type_expr (subst_univar scope vars) ty
- end
- in
- let vars = ref [] in
- let ty =
- For_copy.with_scope (fun scope ->
- subst_univar scope vars ty;
- unmark_type ty;
- copy scope ty
- )
+ match ty.desc with
+ | Tvar name when ty.level = generic_level ->
+ For_copy.save_desc scope ty ty.desc;
+ let t = newty (Tunivar name) in
+ ty.desc <- Tsubst t;
+ Some t
+ | _ -> None
in
- newty2 ty.level (Tpoly(repr ty, !vars))
+ (* need to expand twice? cf. Ctype.unify2 *)
+ let vars = List.map (expand_head env) vars in
+ let vars = List.map (expand_head env) vars in
+ For_copy.with_scope (fun scope ->
+ let vars' = List.filter_map (subst_univar scope) vars in
+ let ty = copy scope ty in
+ let ty = newty2 ty.level (Tpoly(repr ty, vars')) in
+ let complete = List.length vars = List.length vars' in
+ ty, complete
+ )
+(* assumption: [ty] is fully generalized. *)
+let reify_univars env ty =
+ let vars = free_variables ty in
+ let ty, _ = polyfy env ty vars in
+ ty
(*****************)
(* Unification *)
(* force unification in Reither when one side has a non-conjunctive type *)
let rigid_variants = ref false
-(* drop not force unification in Reither, even in fixed case
- (not sound, only use it when checking exhaustiveness) *)
-let passive_variants = ref false
-let with_passive_variants f x =
- if !passive_variants then f x else
- match passive_variants := true; f x with
- | r -> passive_variants := false; r
- | exception e -> passive_variants := false; raise e
-
let unify_eq t1 t2 =
t1 == t2 ||
match !umode with
end;
let fixed1 = fixed_explanation row1 and fixed2 = fixed_explanation row2 in
let more = match fixed1, fixed2 with
- | Some _, _ -> rm1
+ | Some _, Some _ -> if rm2.level < rm1.level then rm2 else rm1
+ | Some _, None -> rm1
| None, Some _ -> rm2
| None, None -> newty2 (min rm1.level rm2.level) (Tvar None)
in
set_more row1 r2;
List.iter
(fun (l,f1,f2) ->
- try unify_row_field env fixed1 fixed2 more l f1 f2
+ try unify_row_field env fixed1 fixed2 rm1 rm2 l f1 f2
with Unify trace ->
raise Trace.( Unify( Variant (Incompatible_types_for l) :: trace ))
)
set_type_desc rm1 md1; set_type_desc rm2 md2; raise exn
end
-and unify_row_field env fixed1 fixed2 more l f1 f2 =
+and unify_row_field env fixed1 fixed2 rm1 rm2 l f1 f2 =
let f1 = row_field_repr f1 and f2 = row_field_repr f2 in
let if_not_fixed (pos,fixed) f =
match fixed with
List.iter2 (unify env) tl1 tl2
end
else let redo =
- not !passive_variants &&
(m1 || m2 || either_fixed ||
!rigid_variants && (List.length tl1 = 1 || List.length tl2 = 1)) &&
begin match tl1 @ tl2 with [] -> false
List.iter (unify env t1) tl;
!e1 <> None || !e2 <> None
end in
- if redo then unify_row_field env fixed1 fixed2 more l f1 f2 else
+ if redo then unify_row_field env fixed1 fixed2 rm1 rm2 l f1 f2 else
let tl1 = List.map repr tl1 and tl2 = List.map repr tl2 in
let rec remq tl = function [] -> []
| ty :: tl' ->
if List.memq ty tl then remq tl tl' else ty :: remq tl tl'
in
- let tl2' = remq tl2 tl1 and tl1' = remq tl1 tl2 in
+ let tl1' = remq tl2 tl1 and tl2' = remq tl1 tl2 in
(* PR#6744 *)
let split_univars =
List.partition
[], [] -> ()
| (tu1::tlu1), _ :: _ ->
(* Attempt to merge all the types containing univars *)
- if not !passive_variants then
List.iter (unify env tu1) (tlu1@tlu2)
| (tu::_, []) | ([], tu::_) -> occur_univar !env tu
end;
(* Is this handling of levels really principal? *)
List.iter (fun ty ->
- let rm = repr more in
+ let rm = repr rm2 in
+ update_level !env rm.level ty;
+ update_scope rm.scope ty;
+ ) tl1';
+ List.iter (fun ty ->
+ let rm = repr rm1 in
update_level !env rm.level ty;
update_scope rm.scope ty;
- ) (tl1' @ tl2');
+ ) tl2';
let e = ref None in
- let f1' = Reither(c1 || c2, tl1', m1 || m2, e)
- and f2' = Reither(c1 || c2, tl2', m1 || m2, e) in
+ let f1' = Reither(c1 || c2, tl2', m1 || m2, e)
+ and f2' = Reither(c1 || c2, tl1', m1 || m2, e) in
set_row_field e1 f1'; set_row_field e2 f2';
| Reither(_, _, false, e1), Rabsent ->
if_not_fixed first (fun () -> set_row_field e1 f2)
| Reither(false, tl, _, e1), Rpresent(Some t2) ->
if_not_fixed first (fun () ->
set_row_field e1 f2;
- let rm = repr more in
+ let rm = repr rm1 in
update_level !env rm.level t2;
update_scope rm.scope t2;
(try List.iter (fun t1 -> unify env t1 t2) tl
| Rpresent(Some t1), Reither(false, tl, _, e2) ->
if_not_fixed second (fun () ->
set_row_field e2 f1;
- let rm = repr more in
+ let rm = repr rm2 in
update_level !env rm.level t1;
update_scope rm.scope t1;
(try List.iter (unify env t1) tl
if ty.level > level then begin
if is_Tvar ty && ty.level >= generic_level - 1 then raise Occur;
ty.level <- pivot_level - ty.level;
- match ty.desc with
- Tvariant row when static_row row ->
- iter_row occur row
- | _ ->
- iter_type_expr occur ty
+ iter_type_expr occur ty
end
in
begin try
(t, Unchanged)
else
(t, Unchanged)
- | Tarrow(l, t1, t2, _) ->
+ | Tarrow(l, t1, t2, com) ->
+ assert (com = Cok);
if memq_warn t visited then (t, Unchanged) else
let visited = t :: visited in
let (t1', c1) = build_subtype env visited loops (not posi) level t1 in
type_manifest = tm;
type_private = priv;
type_variance = decl.type_variance;
+ type_separability = decl.type_separability;
type_is_newtype = false;
type_expansion_scope = Btype.lowest_level;
type_loc = decl.type_loc;
type_attributes = decl.type_attributes;
type_immediate = decl.type_immediate;
type_unboxed = decl.type_unboxed;
+ type_uid = decl.type_uid;
}
with Nondep_cannot_erase _ as exn ->
clear_hash ();
ext_private = ext.ext_private;
ext_attributes = ext.ext_attributes;
ext_loc = ext.ext_loc;
+ ext_uid = ext.ext_uid;
}
with Nondep_cannot_erase _ as exn ->
clear_hash ();
end;
cty_loc = decl.cty_loc;
cty_attributes = decl.cty_attributes;
+ cty_uid = decl.cty_uid;
}
in
clear_hash ();
clty_path = decl.clty_path;
clty_loc = decl.clty_loc;
clty_attributes = decl.clty_attributes;
+ clty_uid = decl.clty_uid;
}
in
clear_hash ();
?keep_names:bool ->
bool -> type_expr list -> type_expr -> type_expr list * type_expr
(* Take an instance of a type scheme containing free univars *)
+val polyfy: Env.t -> type_expr -> type_expr list -> type_expr * bool
val instance_label:
bool -> label_description -> type_expr list * type_expr * type_expr
(* Same, for a label *)
val unify_var: Env.t -> type_expr -> type_expr -> unit
(* Same as [unify], but allow free univars when first type
is a variable. *)
-val with_passive_variants: ('a -> 'b) -> ('a -> 'b)
- (* Call [f] in passive_variants mode, for exhaustiveness check. *)
val filter_arrow: Env.t -> type_expr -> arg_label -> type_expr * type_expr
(* A special case of unification (with l:'a -> 'b). *)
val filter_method: Env.t -> string -> private_flag -> type_expr -> type_expr
(* Same as [moregeneral false], implemented using the two above
functions and backtracking. Ignore levels *)
-val reify_univars : Types.type_expr -> Types.type_expr
+val reify_univars : Env.t -> Types.type_expr -> Types.type_expr
(* Replaces all the variables of a type by a univar. *)
type class_match_failure =
in
(tyl, existentials)
-let constructor_args priv cd_args cd_res path rep =
+let constructor_args ~current_unit priv cd_args cd_res path rep =
let tyl, existentials = constructor_existentials cd_args cd_res in
match cd_args with
| Cstr_tuple l -> existentials, l, None
| Record_unboxed _ -> unboxed_true_default_false
| _ -> unboxed_false_default_false
in
+ let arity = List.length type_params in
let tdecl =
{
type_params;
- type_arity = List.length type_params;
+ type_arity = arity;
type_kind = Type_record (lbls, rep);
type_private = priv;
type_manifest = None;
type_variance = List.map (fun _ -> Variance.full) type_params;
+ type_separability = Types.Separability.default_signature ~arity;
type_is_newtype = false;
type_expansion_scope = Btype.lowest_level;
type_loc = Location.none;
type_attributes = [];
type_immediate = Unknown;
type_unboxed;
+ type_uid = Uid.mk ~current_unit;
}
in
existentials,
[ newgenconstr path type_params ],
Some tdecl
-let constructor_descrs ty_path decl cstrs =
+let constructor_descrs ~current_unit ty_path decl cstrs =
let ty_res = newgenconstr ty_path decl.type_params in
let num_consts = ref 0 and num_nonconsts = ref 0 and num_normal = ref 0 in
List.iter
cstrs;
let rec describe_constructors idx_const idx_nonconst = function
[] -> []
- | {cd_id; cd_args; cd_res; cd_loc; cd_attributes} :: rem ->
+ | {cd_id; cd_args; cd_res; cd_loc; cd_attributes; cd_uid} :: rem ->
let ty_res =
match cd_res with
| Some ty_res' -> ty_res'
then Record_unboxed true
else Record_inlined idx_nonconst
in
- constructor_args decl.type_private cd_args cd_res
+ constructor_args ~current_unit decl.type_private cd_args cd_res
(Path.Pdot (ty_path, cstr_name)) representation
in
let cstr =
cstr_loc = cd_loc;
cstr_attributes = cd_attributes;
cstr_inlined;
+ cstr_uid = cd_uid;
} in
(cd_id, cstr) :: descr_rem in
describe_constructors 0 0 cstrs
-let extension_descr path_ext ext =
+let extension_descr ~current_unit path_ext ext =
let ty_res =
match ext.ext_ret_type with
Some type_ret -> type_ret
| None -> newgenconstr ext.ext_type_path ext.ext_type_params
in
let existentials, cstr_args, cstr_inlined =
- constructor_args ext.ext_private ext.ext_args ext.ext_ret_type
+ constructor_args ~current_unit ext.ext_private ext.ext_args ext.ext_ret_type
path_ext (Record_extension path_ext)
in
{ cstr_name = Path.last path_ext;
cstr_loc = ext.ext_loc;
cstr_attributes = ext.ext_attributes;
cstr_inlined;
+ cstr_uid = ext.ext_uid;
}
let none = {desc = Ttuple []; level = -1; scope = Btype.generic_level; id = -1}
lbl_private = Public;
lbl_loc = Location.none;
lbl_attributes = [];
+ lbl_uid = Uid.internal_not_actually_unique;
}
let label_descrs ty_res lbls repres priv =
lbl_private = priv;
lbl_loc = l.ld_loc;
lbl_attributes = l.ld_attributes;
+ lbl_uid = l.ld_uid;
} in
all_labels.(num) <- lbl;
(l.ld_id, lbl) :: describe_labels (num+1) rest in
let find_constr_by_tag tag cstrlist =
find_constr tag 0 0 cstrlist
-let constructors_of_type ty_path decl =
+let constructors_of_type ~current_unit ty_path decl =
match decl.type_kind with
- | Type_variant cstrs -> constructor_descrs ty_path decl cstrs
+ | Type_variant cstrs -> constructor_descrs ~current_unit ty_path decl cstrs
| Type_record _ | Type_abstract | Type_open -> []
let labels_of_type ty_path decl =
open Types
val extension_descr:
- Path.t -> extension_constructor -> constructor_description
+ current_unit:string -> Path.t -> extension_constructor ->
+ constructor_description
val labels_of_type:
Path.t -> type_declaration ->
(Ident.t * label_description) list
val constructors_of_type:
- Path.t -> type_declaration ->
+ current_unit:string -> Path.t -> type_declaration ->
(Ident.t * constructor_description) list
let add_delayed_check_forward = ref (fun _ -> assert false)
-let value_declarations : ((string * Location.t), (unit -> unit)) Hashtbl.t =
- Hashtbl.create 16
- (* This table is used to usage of value declarations. A declaration is
- identified with its name and location. The callback attached to a
- declaration is called whenever the value is used explicitly
- (lookup_value) or implicitly (inclusion test between signatures,
- cf Includemod.value_descriptions). *)
-
-let type_declarations = Hashtbl.create 16
-let module_declarations = Hashtbl.create 16
+type 'a usage_tbl = ('a -> unit) Types.Uid.Tbl.t
+(** This table is used to track usage of value declarations.
+ A declaration is identified by its uid.
+ The callback attached to a declaration is called whenever the value (or
+ type, or ...) is used explicitly (lookup_value, ...) or implicitly
+ (inclusion test between signatures, cf Includemod.value_descriptions, ...).
+*)
+
+let value_declarations : unit usage_tbl = Types.Uid.Tbl.create 16
+let type_declarations : unit usage_tbl = Types.Uid.Tbl.create 16
+let module_declarations : unit usage_tbl = Types.Uid.Tbl.create 16
type constructor_usage = Positive | Pattern | Privatize
type constructor_usages =
mutable cu_pattern: bool;
mutable cu_privatize: bool;
}
-let add_constructor_usage priv cu usage =
- match priv with
- | Asttypes.Private -> cu.cu_positive <- true
- | Asttypes.Public -> begin
- match usage with
- | Positive -> cu.cu_positive <- true
- | Pattern -> cu.cu_pattern <- true
- | Privatize -> cu.cu_privatize <- true
- end
+let add_constructor_usage ~rebind priv cu usage =
+ let private_or_rebind =
+ match priv with
+ | Asttypes.Private -> true
+ | Asttypes.Public -> rebind
+ in
+ if private_or_rebind then begin
+ cu.cu_positive <- true
+ end else begin
+ match usage with
+ | Positive -> cu.cu_positive <- true
+ | Pattern -> cu.cu_pattern <- true
+ | Privatize -> cu.cu_privatize <- true
+ end
let constructor_usages () =
{cu_positive = false; cu_pattern = false; cu_privatize = false}
-let used_constructors :
- (string * Location.t * string, (constructor_usage -> unit)) Hashtbl.t
- = Hashtbl.create 16
+let used_constructors : constructor_usage usage_tbl = Types.Uid.Tbl.create 16
(** Map indexed by the name of module components. *)
module NameMap = String.Map
and module_components =
{
alerts: alerts;
- loc: Location.t;
+ uid: Uid.t;
comps:
(components_maker,
(module_components_repr, module_components_failure) result)
aliasable:bool -> t -> module_type -> Path.t -> module_type)
let md md_type =
- {md_type; md_attributes=[]; md_loc=Location.none}
+ {md_type; md_attributes=[]; md_loc=Location.none
+ ;md_uid = Uid.internal_not_actually_unique}
(* Print addresses *)
let add_persistent_structure id env =
if not (Ident.persistent id) then invalid_arg "Env.add_persistent_structure";
if not (Current_unit_name.is_name_of id) then
+ let summary =
+ match
+ IdTbl.find_name wrap_module ~mark:false (Ident.name id) env.modules
+ with
+ | exception Not_found | _, Mod_persistent -> env.summary
+ | _ -> Env_persistent (env.summary, id)
+ in
{ env with
modules = IdTbl.add id Mod_persistent env.modules;
- summary = Env_persistent (env.summary, id);
+ summary
}
else
env
-let components_of_module ~alerts ~loc env fs ps path addr mty =
+let components_of_module ~alerts ~uid env fs ps path addr mty =
{
alerts;
- loc;
+ uid;
comps = EnvLazy.create {
cm_env = env;
cm_freshening_subst = fs;
Misc.Stdlib.String.Map.empty
flags
in
- let loc = Location.none in
- let md = md (Mty_signature sign) in
+ let md =
+ { md_type = Mty_signature sign;
+ md_loc = Location.none;
+ md_attributes = [];
+ md_uid = Uid.of_compilation_unit_id id;
+ }
+ in
let mda_address = EnvLazy.create_forced (Aident id) in
let mda_declaration =
EnvLazy.create (Subst.identity, Subst.Make_local, md)
let freshening_subst =
if freshen then (Some Subst.identity) else None
in
- components_of_module ~alerts ~loc
+ components_of_module ~alerts ~uid:md.md_uid
empty freshening_subst Subst.identity
path mda_address (Mty_signature sign)
in
let is_imported_opaque modname =
Persistent_env.is_imported_opaque persistent_env modname
+let register_import_as_opaque modname =
+ Persistent_env.register_import_as_opaque persistent_env modname
+
let reset_declaration_caches () =
- Hashtbl.clear value_declarations;
- Hashtbl.clear type_declarations;
- Hashtbl.clear module_declarations;
- Hashtbl.clear used_constructors;
+ Types.Uid.Tbl.clear value_declarations;
+ Types.Uid.Tbl.clear type_declarations;
+ Types.Uid.Tbl.clear module_declarations;
+ Types.Uid.Tbl.clear used_constructors;
()
let reset_cache () =
Hashtbl.add fcomp.fcomp_subst_cache p2 mty;
mty
+let check_functor_appl ~errors ~loc env p1 f arg p2 md =
+ if not (Hashtbl.mem f.fcomp_cache p2) then
+ !check_functor_application ~errors ~loc env md.md_type p2 arg p1
+
(* Lookup by identifier *)
let find_ident_module id env =
| Papply _ ->
assert false
+let rec normalize_modtype_path env path =
+ let path = normalize_path_prefix None env path in
+ expand_modtype_path env path
+
+and expand_modtype_path env path =
+ match (find_modtype path env).mtd_type with
+ | Some (Mty_ident path) -> normalize_modtype_path env path
+ | _ | exception Not_found -> path
+
let find_module path env =
find_module ~alias:false path env
Datarepr.set_row_name final_decl
(Subst.type_path prefixing_sub (Path.Pident id));
let constructors =
- List.map snd (Datarepr.constructors_of_type path final_decl) in
+ List.map snd
+ (Datarepr.constructors_of_type ~current_unit:(get_unit_name ())
+ path final_decl)
+ in
let labels =
List.map snd (Datarepr.labels_of_type path final_decl) in
let tda =
env := store_type_infos id fresh_decl !env
| Sig_typext(id, ext, _, _) ->
let ext' = Subst.extension_constructor sub ext in
- let descr = Datarepr.extension_descr path ext' in
+ let descr =
+ Datarepr.extension_descr ~current_unit:(get_unit_name ()) path
+ ext'
+ in
let addr = next_address () in
let cda = { cda_description = descr; cda_address = Some addr } in
c.comp_constrs <- add_to_tbl (Ident.name id) cda c.comp_constrs
Builtin_attributes.alerts_of_attrs md.md_attributes
in
let comps =
- components_of_module ~alerts ~loc:md.md_loc !env freshening_sub
+ components_of_module ~alerts ~uid:md.md_uid !env freshening_sub
prefixing_sub path addr md.md_type
in
let mda =
(* Insertion of bindings by identifier + path *)
-and check_usage loc id warn tbl =
- if not loc.Location.loc_ghost && Warnings.is_active (warn "") then begin
+and check_usage loc id uid warn tbl =
+ if not loc.Location.loc_ghost &&
+ Uid.for_actual_declaration uid &&
+ Warnings.is_active (warn "")
+ then begin
let name = Ident.name id in
- let key = (name, loc) in
- if Hashtbl.mem tbl key then ()
+ if Types.Uid.Tbl.mem tbl uid then ()
else let used = ref false in
- Hashtbl.add tbl key (fun () -> used := true);
+ Types.Uid.Tbl.add tbl uid (fun () -> used := true);
if not (name = "" || name.[0] = '_' || name.[0] = '#')
then
!add_delayed_check_forward
and store_value ?check id addr decl env =
check_value_name (Ident.name id) decl.val_loc;
- Option.iter (fun f -> check_usage decl.val_loc id f value_declarations) check;
+ Option.iter
+ (fun f -> check_usage decl.val_loc id decl.val_uid f value_declarations)
+ check;
let vda = { vda_description = decl; vda_address = addr } in
{ env with
values = IdTbl.add id (Val_bound vda) env.values;
and store_type ~check id info env =
let loc = info.type_loc in
if check then
- check_usage loc id (fun s -> Warnings.Unused_type_declaration s)
+ check_usage loc id info.type_uid
+ (fun s -> Warnings.Unused_type_declaration s)
type_declarations;
let path = Pident id in
- let constructors = Datarepr.constructors_of_type path info in
+ let constructors =
+ Datarepr.constructors_of_type path info
+ ~current_unit:(get_unit_name ())
+ in
let labels = Datarepr.labels_of_type path info in
let descrs = (List.map snd constructors, List.map snd labels) in
let tda = { tda_declaration = info; tda_descriptions = descrs } in
begin fun (_, cstr) ->
let name = cstr.cstr_name in
let loc = cstr.cstr_loc in
- let k = (ty_name, loc, name) in
- if not (Hashtbl.mem used_constructors k) then
+ let k = cstr.cstr_uid in
+ if not (Types.Uid.Tbl.mem used_constructors k) then
let used = constructor_usages () in
- Hashtbl.add used_constructors k (add_constructor_usage priv used);
+ Types.Uid.Tbl.add used_constructors k
+ (add_constructor_usage ~rebind:false priv used);
if not (ty_name = "" || ty_name.[0] = '_')
then !add_delayed_check_forward
(fun () ->
types = IdTbl.add id tda env.types;
summary = Env_type(env.summary, id, info) }
-and store_extension ~check id addr ext env =
+and store_extension ~check ~rebind id addr ext env =
let loc = ext.ext_loc in
- let cstr = Datarepr.extension_descr (Pident id) ext in
+ let cstr =
+ Datarepr.extension_descr ~current_unit:(get_unit_name ()) (Pident id) ext
+ in
let cda = { cda_description = cstr; cda_address = Some addr } in
if check && not loc.Location.loc_ghost &&
Warnings.is_active (Warnings.Unused_extension ("", false, false, false))
then begin
let priv = ext.ext_private in
let is_exception = Path.same ext.ext_type_path Predef.path_exn in
- let ty_name = Path.last ext.ext_type_path in
let name = cstr.cstr_name in
- let k = (ty_name, loc, name) in
- if not (Hashtbl.mem used_constructors k) then begin
+ let k = cstr.cstr_uid in
+ if not (Types.Uid.Tbl.mem used_constructors k) then begin
let used = constructor_usages () in
- Hashtbl.add used_constructors k (add_constructor_usage priv used);
+ Types.Uid.Tbl.add used_constructors k
+ (add_constructor_usage ~rebind priv used);
!add_delayed_check_forward
(fun () ->
if not (is_in_signature env) && not used.cu_positive then
and store_module ~check ~freshening_sub id addr presence md env =
let loc = md.md_loc in
- Option.iter (fun f -> check_usage loc id f module_declarations) check;
+ Option.iter
+ (fun f -> check_usage loc id md.md_uid f module_declarations) check;
let alerts = Builtin_attributes.alerts_of_attrs md.md_attributes in
let module_decl_lazy =
match freshening_sub with
| Some s -> EnvLazy.create (s, Subst.Rescope (Ident.scope id), md)
in
let comps =
- components_of_module ~alerts ~loc:md.md_loc
+ components_of_module ~alerts ~uid:md.md_uid
env freshening_sub Subst.identity (Pident id) addr md.md_type
in
let mda =
("the signature of " ^ Path.name p) mty;
let comps =
components_of_module ~alerts:Misc.Stdlib.String.Map.empty
- ~loc:Location.none
+ ~uid:Uid.internal_not_actually_unique
(*???*)
env None Subst.identity p addr mty
in
let add_type ~check id info env =
store_type ~check id info env
-and add_extension ~check id ext env =
+and add_extension ~check ~rebind id ext env =
let addr = extension_declaration_address env id ext in
- store_extension ~check id addr ext env
+ store_extension ~check ~rebind id addr ext env
and add_module_declaration ?(arg=false) ~check id presence md env =
let check =
let env = store_type ~check:true id info env in
(id, env)
-let enter_extension ~scope name ext env =
+let enter_extension ~scope ~rebind name ext env =
let id = Ident.create_scoped ~scope name in
let addr = extension_declaration_address env id ext in
- let env = store_extension ~check:true id addr ext env in
+ let env = store_extension ~check:true ~rebind id addr ext env in
(id, env)
let enter_module_declaration ~scope ?arg s presence md env =
match comp with
Sig_value(id, decl, _) -> add_value id decl env
| Sig_type(id, decl, _, _) -> add_type ~check:false id decl env
- | Sig_typext(id, ext, _, _) -> add_extension ~check:false id ext env
+ | Sig_typext(id, ext, _, _) ->
+ add_extension ~check:false ~rebind:false id ext env
| Sig_module(id, presence, md, _, _) ->
add_module_declaration ~check:false id presence md env
| Sig_modtype(id, decl, _) -> add_modtype id decl env
modules;
}
-let open_signature slot root env0 =
- match get_components (find_module_components root env0) with
- | Functor_comps _ -> None
- | Structure_comps comps ->
- Some (add_components slot root env0 comps)
+let open_signature slot root env0 : (_,_) result =
+ match get_components_res (find_module_components root env0) with
+ | Error _ -> Error `Not_found
+ | exception Not_found -> Error `Not_found
+ | Ok (Functor_comps _) -> Error `Functor
+ | Ok (Structure_comps comps) ->
+ Ok (add_components slot root env0 comps)
(* Open a signature from a file *)
let open_pers_signature name env =
match open_signature None (Pident(Ident.create_persistent name)) env with
- | Some env -> env
- | None -> assert false (* a compilation unit cannot refer to a functor *)
+ | (Ok _ | Error `Not_found as res) -> res
+ | Error `Functor -> assert false
+ (* a compilation unit cannot refer to a functor *)
let open_signature
?(used_slot = ref false)
let (initial_safe_string, initial_unsafe_string) =
Predef.build_initial_env
(add_type ~check:false)
- (add_extension ~check:false)
+ (add_extension ~check:false ~rebind:false)
empty
(* Tracking usage *)
-let mark_module_used name loc =
- match Hashtbl.find module_declarations (name, loc) with
+let mark_module_used uid =
+ match Types.Uid.Tbl.find module_declarations uid with
| mark -> mark ()
| exception Not_found -> ()
-let mark_modtype_used _name _mtd = ()
+let mark_modtype_used _uid = ()
-let mark_value_used name vd =
- match Hashtbl.find value_declarations (name, vd.val_loc) with
+let mark_value_used uid =
+ match Types.Uid.Tbl.find value_declarations uid with
| mark -> mark ()
| exception Not_found -> ()
-let mark_type_used name td =
- match Hashtbl.find type_declarations (name, td.type_loc) with
+let mark_type_used uid =
+ match Types.Uid.Tbl.find type_declarations uid with
| mark -> mark ()
| exception Not_found -> ()
let mark_type_path_used env path =
match find_type path env with
- | decl -> mark_type_used (Path.last path) decl
+ | decl -> mark_type_used decl.type_uid
| exception Not_found -> ()
-let mark_constructor_used usage ty_name cd =
- let name = Ident.name cd.cd_id in
- let loc = cd.cd_loc in
- let k = (ty_name, loc, name) in
- match Hashtbl.find used_constructors k with
+let mark_constructor_used usage cd =
+ match Types.Uid.Tbl.find used_constructors cd.cd_uid with
| mark -> mark usage
| exception Not_found -> ()
-let mark_extension_used usage name ext =
- let ty_name = Path.last ext.ext_type_path in
- let loc = ext.ext_loc in
- let k = (ty_name, loc, name) in
- match Hashtbl.find used_constructors k with
+let mark_extension_used usage ext =
+ match Types.Uid.Tbl.find used_constructors ext.ext_uid with
| mark -> mark usage
| exception Not_found -> ()
| _ -> assert false
in
mark_type_path_used env ty_path;
- let ty_name = Path.last ty_path in
- let k = (ty_name, cstr.cstr_loc, cstr.cstr_name) in
- match Hashtbl.find used_constructors k with
+ match Types.Uid.Tbl.find used_constructors cstr.cstr_uid with
| mark -> mark usage
| exception Not_found -> ()
in
mark_type_path_used env ty_path
-let mark_class_used name cty =
- match Hashtbl.find type_declarations (name, cty.cty_loc) with
+let mark_class_used uid =
+ match Types.Uid.Tbl.find type_declarations uid with
| mark -> mark ()
| exception Not_found -> ()
-let mark_cltype_used name clty =
- match Hashtbl.find type_declarations (name, clty.clty_loc) with
+let mark_cltype_used uid =
+ match Types.Uid.Tbl.find type_declarations uid with
| mark -> mark ()
| exception Not_found -> ()
-let set_value_used_callback name vd callback =
- let key = (name, vd.val_loc) in
- try
- let old = Hashtbl.find value_declarations key in
- Hashtbl.replace value_declarations key (fun () -> old (); callback ())
- (* this is to support cases like:
- let x = let x = 1 in x in x
- where the two declarations have the same location
- (e.g. resulting from Camlp4 expansion of grammar entries) *)
- with Not_found ->
- Hashtbl.add value_declarations key callback
-
-let set_type_used_callback name td callback =
- let loc = td.type_loc in
- if loc.Location.loc_ghost then ()
- else let key = (name, loc) in
- let old =
- try Hashtbl.find type_declarations key
- with Not_found -> ignore
- in
- Hashtbl.replace type_declarations key (fun () -> callback old)
+let set_value_used_callback vd callback =
+ Types.Uid.Tbl.add value_declarations vd.val_uid callback
+
+let set_type_used_callback td callback =
+ if Uid.for_actual_declaration td.type_uid then
+ let old =
+ try Types.Uid.Tbl.find type_declarations td.type_uid
+ with Not_found -> ignore
+ in
+ Types.Uid.Tbl.replace type_declarations td.type_uid (fun () -> callback old)
(* Lookup by name *)
in
may_lookup_error errors loc env (Unbound_value(lid, hint))
-let use_module ~use ~loc name path mda =
+let use_module ~use ~loc path mda =
if use then begin
let comps = mda.mda_components in
- mark_module_used name comps.loc;
+ mark_module_used comps.uid;
Misc.Stdlib.String.Map.iter
(fun kind message ->
let message = if message = "" then "" else "\n" ^ message in
comps.alerts
end
-let use_value ~use ~loc name path vda =
+let use_value ~use ~loc path vda =
if use then begin
let desc = vda.vda_description in
- mark_value_used name desc;
+ mark_value_used desc.val_uid;
Builtin_attributes.check_alerts loc desc.val_attributes
(Path.name path)
end
-let use_type ~use ~loc name path tda =
+let use_type ~use ~loc path tda =
if use then begin
let decl = tda.tda_declaration in
- mark_type_used name decl;
+ mark_type_used decl.type_uid;
Builtin_attributes.check_alerts loc decl.type_attributes
(Path.name path)
end
-let use_modtype ~use ~loc name path desc =
+let use_modtype ~use ~loc path desc =
if use then begin
- mark_modtype_used name desc;
+ mark_modtype_used desc.mtd_uid;
Builtin_attributes.check_alerts loc desc.mtd_attributes
(Path.name path)
end
-let use_class ~use ~loc name path clda =
+let use_class ~use ~loc path clda =
if use then begin
let desc = clda.clda_declaration in
- mark_class_used name desc;
+ mark_class_used desc.cty_uid;
Builtin_attributes.check_alerts loc desc.cty_attributes
(Path.name path)
end
-let use_cltype ~use ~loc name path desc =
+let use_cltype ~use ~loc path desc =
if use then begin
- mark_cltype_used name desc;
+ mark_cltype_used desc.clty_uid;
Builtin_attributes.check_alerts loc desc.clty_attributes
(Path.name path)
end
in
match data with
| Mod_local mda -> begin
- use_module ~use ~loc s path mda;
+ use_module ~use ~loc path mda;
match load with
| Load -> path, (mda : a)
| Don't_load -> path, (() : a)
| Load -> begin
match find_pers_mod s with
| mda ->
- use_module ~use ~loc s path mda;
+ use_module ~use ~loc path mda;
path, (mda : a)
| exception Not_found ->
may_lookup_error errors loc env (Unbound_module (Lident s))
let lookup_ident_value ~errors ~use ~loc name env =
match IdTbl.find_name wrap_value ~mark:use name env.values with
| (path, Val_bound vda) ->
- use_value ~use ~loc name path vda;
+ use_value ~use ~loc path vda;
path, vda.vda_description
| (_, Val_unbound reason) ->
report_value_unbound ~errors ~loc env reason (Lident name)
let lookup_ident_type ~errors ~use ~loc s env =
match IdTbl.find_name wrap_identity ~mark:use s env.types with
| (path, data) as res ->
- use_type ~use ~loc s path data;
+ use_type ~use ~loc path data;
res
| exception Not_found ->
may_lookup_error errors loc env (Unbound_type (Lident s))
let lookup_ident_modtype ~errors ~use ~loc s env =
match IdTbl.find_name wrap_identity ~mark:use s env.modtypes with
| (path, data) as res ->
- use_modtype ~use ~loc s path data;
+ use_modtype ~use ~loc path data;
res
| exception Not_found ->
may_lookup_error errors loc env (Unbound_modtype (Lident s))
let lookup_ident_class ~errors ~use ~loc s env =
match IdTbl.find_name wrap_identity ~mark:use s env.classes with
| (path, clda) ->
- use_class ~use ~loc s path clda;
+ use_class ~use ~loc path clda;
path, clda.clda_declaration
| exception Not_found ->
may_lookup_error errors loc env (Unbound_class (Lident s))
let lookup_ident_cltype ~errors ~use ~loc s env =
match IdTbl.find_name wrap_identity ~mark:use s env.cltypes with
| (path, data) as res ->
- use_cltype ~use ~loc s path data;
+ use_cltype ~use ~loc path data;
res
| exception Not_found ->
may_lookup_error errors loc env (Unbound_cltype (Lident s))
lbls
end
-(* Drop all extension constructors *)
-let drop_exts cstrs =
- List.filter (fun (cda, _) -> not (is_ext cda)) cstrs
-
-(* Only keep the latest extension constructor *)
-let rec filter_shadowed_constructors cstrs =
- match cstrs with
- | (cda, _) as hd :: tl ->
- if is_ext cda then hd :: drop_exts tl
- else hd :: filter_shadowed_constructors tl
- | [] -> []
-
let lookup_all_ident_constructors ~errors ~use ~loc usage s env =
match TycompTbl.find_all ~mark:use s env.constrs with
| [] -> may_lookup_error errors loc env (Unbound_constructor (Lident s))
| cstrs ->
- let cstrs = filter_shadowed_constructors cstrs in
List.map
(fun (cda, use_fn) ->
let use_fn () =
| Lapply(l1, l2) ->
let p1, f, arg = lookup_functor_components ~errors ~use ~loc l1 env in
let p2, md = lookup_module ~errors ~use ~loc l2 env in
- !check_functor_application ~errors ~loc env md.md_type p2 arg p1;
+ check_functor_appl ~errors ~loc env p1 f arg p2 md;
let comps = !components_of_functor_appl' ~loc f env p1 p2 in
(Papply(p1, p2), comps)
| Lapply(l1, l2) ->
let p1, fc, arg = lookup_functor_components ~errors ~use ~loc l1 env in
let p2, md2 = lookup_module ~errors ~use ~loc l2 env in
- !check_functor_application ~errors ~loc env md2.md_type p2 arg p1;
+ check_functor_appl ~errors ~loc env p1 fc arg p2 md2;
let md = md (modtype_of_functor_appl fc p1 p2) in
Papply(p1, p2), md
match NameMap.find s comps.comp_modules with
| mda ->
let path = Pdot(p, s) in
- use_module ~use ~loc s path mda;
+ use_module ~use ~loc path mda;
(path, mda)
| exception Not_found ->
may_lookup_error errors loc env (Unbound_module (Ldot(l, s)))
match NameMap.find s comps.comp_values with
| vda ->
let path = Pdot(path, s) in
- use_value ~use ~loc s path vda;
+ use_value ~use ~loc path vda;
(path, vda.vda_description)
| exception Not_found ->
may_lookup_error errors loc env (Unbound_value (Ldot(l, s), No_hint))
match NameMap.find s comps.comp_types with
| tda ->
let path = Pdot(p, s) in
- use_type ~use ~loc s path tda;
+ use_type ~use ~loc path tda;
(path, tda)
| exception Not_found ->
may_lookup_error errors loc env (Unbound_type (Ldot(l, s)))
match NameMap.find s comps.comp_modtypes with
| desc ->
let path = Pdot(p, s) in
- use_modtype ~use ~loc s path desc;
+ use_modtype ~use ~loc path desc;
(path, desc)
| exception Not_found ->
may_lookup_error errors loc env (Unbound_modtype (Ldot(l, s)))
match NameMap.find s comps.comp_classes with
| clda ->
let path = Pdot(p, s) in
- use_class ~use ~loc s path clda;
+ use_class ~use ~loc path clda;
(path, clda.clda_declaration)
| exception Not_found ->
may_lookup_error errors loc env (Unbound_class (Ldot(l, s)))
match NameMap.find s comps.comp_cltypes with
| desc ->
let path = Pdot(p, s) in
- use_cltype ~use ~loc s path desc;
+ use_cltype ~use ~loc path desc;
(path, desc)
| exception Not_found ->
may_lookup_error errors loc env (Unbound_cltype (Ldot(l, s)))
fst (lookup_ident_module Load ~errors ~use ~loc s env)
| Ldot(l, s) -> fst (lookup_dot_module ~errors ~use ~loc l s env)
| Lapply(l1, l2) ->
- let (p1, _, arg) = lookup_functor_components ~errors ~use ~loc l1 env in
+ let (p1, f, arg) = lookup_functor_components ~errors ~use ~loc l1 env in
let p2, md2 = lookup_module ~errors ~use ~loc l2 env in
- !check_functor_application ~errors ~loc env md2.md_type p2 arg p1;
+ check_functor_appl ~errors ~loc env p1 f arg p2 md2;
Papply(p1, p2)
let lookup_value ~errors ~use ~loc lid env =
let desc = vda.vda_description in
match desc.val_kind with
| Val_ivar(mut, cl_num) ->
- use_value ~use ~loc name path vda;
+ use_value ~use ~loc path vda;
path, mut, cl_num, desc.val_type
| _ ->
lookup_error loc env (Not_an_instance_variable name)
(* Normalize the prefix part of other kinds of paths
(value/modtype/etc) *)
+val normalize_modtype_path: t -> Path.t -> Path.t
+(* Normalize a module type path *)
val reset_required_globals: unit -> unit
val get_required_globals: unit -> Ident.t list
val has_local_constraints: t -> bool
(* Mark definitions as used *)
-val mark_value_used: string -> value_description -> unit
-val mark_module_used: string -> Location.t -> unit
-val mark_type_used: string -> type_declaration -> unit
+val mark_value_used: Uid.t -> unit
+val mark_module_used: Uid.t -> unit
+val mark_type_used: Uid.t -> unit
type constructor_usage = Positive | Pattern | Privatize
val mark_constructor_used:
- constructor_usage -> string -> constructor_declaration -> unit
+ constructor_usage -> constructor_declaration -> unit
val mark_extension_used:
- constructor_usage -> string -> extension_constructor -> unit
+ constructor_usage -> extension_constructor -> unit
(* Lookup by long identifiers *)
val add_value:
?check:(string -> Warnings.t) -> Ident.t -> value_description -> t -> t
val add_type: check:bool -> Ident.t -> type_declaration -> t -> t
-val add_extension: check:bool -> Ident.t -> extension_constructor -> t -> t
+val add_extension:
+ check:bool -> rebind:bool -> Ident.t -> extension_constructor -> t -> t
val add_module:
?arg:bool -> Ident.t -> module_presence -> module_type -> t -> t
val add_module_declaration: ?arg:bool -> check:bool -> Ident.t ->
?used_slot:bool ref ->
?loc:Location.t -> ?toplevel:bool ->
Asttypes.override_flag -> Path.t ->
- t -> t option
+ t -> (t, [`Not_found | `Functor]) result
-val open_pers_signature: string -> t -> t
+val open_pers_signature: string -> t -> (t, [`Not_found]) result
(* Insertion by name *)
string -> value_description -> t -> Ident.t * t
val enter_type: scope:int -> string -> type_declaration -> t -> Ident.t * t
val enter_extension:
- scope:int -> string -> extension_constructor -> t -> Ident.t * t
+ scope:int -> rebind:bool -> string ->
+ extension_constructor -> t -> Ident.t * t
val enter_module:
scope:int -> ?arg:bool -> string -> module_presence ->
module_type -> t -> Ident.t * t
(* may raise Persistent_env.Consistbl.Inconsistency *)
val import_crcs: source:string -> crcs -> unit
-(* [is_imported_opaque md] returns true if [md] is an opaque imported module *)
+(* [is_imported_opaque md] returns true if [md] is an opaque imported module *)
val is_imported_opaque: modname -> bool
+(* [register_import_as_opaque md] registers [md] as an opaque imported module *)
+val register_import_as_opaque: modname -> unit
+
(* Summaries -- compact representation of an environment, to be
exported in debugging information. *)
val is_in_signature: t -> bool
val set_value_used_callback:
- string -> value_description -> (unit -> unit) -> unit
+ value_description -> (unit -> unit) -> unit
val set_type_used_callback:
- string -> type_declaration -> ((unit -> unit) -> unit) -> unit
+ type_declaration -> ((unit -> unit) -> unit) -> unit
(* Forward declaration to break mutual recursion with Includemod. *)
val check_functor_application:
(* Forward declaration to break mutual recursion with Printtyp. *)
val print_path: (Format.formatter -> Path.t -> unit) ref
+
+(** Folds *)
+
+val fold_constructors:
+ (constructor_description -> 'a -> 'a) ->
+ Longident.t option -> t -> 'a -> 'a
+
(** Utilities *)
val scrape_alias: t -> module_type -> module_type
val check_value_name: string -> Location.t -> unit
(Subst.type_declaration subst desc)
(env_from_summary s subst)
| Env_extension(s, id, desc) ->
- Env.add_extension ~check:false id
+ Env.add_extension ~check:false ~rebind:false id
(Subst.extension_constructor subst desc)
(env_from_summary s subst)
| Env_module(s, id, pres, desc) ->
let env = env_from_summary s subst in
let path' = Subst.module_path subst path in
begin match Env.open_signature Asttypes.Override path' env with
- | Some env -> env
- | None -> assert false
- | exception Not_found -> raise (Error (Module_not_found path'))
+ | Ok env -> env
+ | Error `Functor -> assert false
+ | Error `Not_found -> raise (Error (Module_not_found path'))
end
| Env_functor_arg(Env_module(s, id, pres, desc), id')
when Ident.same id id' ->
let report_error ppf = function
| Module_not_found p ->
fprintf ppf "@[Cannot find module %a@].@." Printtyp.path p
+
+let () =
+ Location.register_error_of_exn
+ (function
+ | Error err -> Some (Location.error_of_printer_file report_error err)
+ | _ -> None
+ )
| _ ->
false
-let same i1 i2 = i1 = i2
- (* Possibly more efficient version (with a real compiler, at least):
- if i1.stamp <> 0
- then i1.stamp = i2.stamp
- else i2.stamp = 0 && i1.name = i2.name *)
-
-let compare i1 i2 = Stdlib.compare i1 i2
+let same i1 i2 =
+ match i1, i2 with
+ | Local { stamp = s1; _ }, Local { stamp = s2; _ }
+ | Scoped { stamp = s1; _ }, Scoped { stamp = s2; _ }
+ | Predef { stamp = s1; _ }, Predef { stamp = s2 } ->
+ s1 = s2
+ | Global name1, Global name2 ->
+ name1 = name2
+ | _ ->
+ false
let stamp = function
| Local { stamp; _ }
Empty ->
Node(Empty, {ident = id; data = data; previous = None}, Empty, 1)
| Node(l, k, r, h) ->
- let c = compare (name id) (name k.ident) in
+ let c = String.compare (name id) (name k.ident) in
if c = 0 then
Node(l, {ident = id; data = data; previous = Some k}, r, h)
else if c < 0 then
Empty ->
Empty
| (Node (l, k, r, h) as m) ->
- let c = compare (name id) (name k.ident) in
+ let c = String.compare (name id) (name k.ident) in
if c = 0 then
match k.previous with
| None -> merge l r
Empty ->
raise Not_found
| Node(l, k, r, _) ->
- let c = compare (name id) (name k.ident) in
+ let c = String.compare (name id) (name k.ident) in
if c = 0 then
if same id k.ident
then k.data
Empty ->
raise Not_found
| Node(l, k, r, _) ->
- let c = compare n (name k.ident) in
+ let c = String.compare n (name k.ident) in
if c = 0 then
k.ident, k.data
else
Empty ->
[]
| Node(l, k, r, _) ->
- let c = compare n (name k.ident) in
+ let c = String.compare n (name k.ident) in
if c = 0 then
(k.ident, k.data) :: get_all k.previous
else
(_, Type_abstract) -> None
| (Type_variant cstrs1, Type_variant cstrs2) ->
if mark then begin
- let mark usage name cstrs =
- List.iter
- (fun cstr ->
- Env.mark_constructor_used usage name cstr)
- cstrs
+ let mark usage cstrs =
+ List.iter (Env.mark_constructor_used usage) cstrs
in
let usage =
if decl2.type_private = Public then Env.Positive
else Env.Privatize
in
- mark usage name cstrs1;
- if equality then mark Env.Positive (Path.name path) cstrs2
+ mark usage cstrs1;
+ if equality then mark Env.Positive cstrs2
end;
Option.map
(fun var_err -> Variant_mismatch var_err)
if ext2.ext_private = Public then Env.Positive
else Env.Privatize
in
- Env.mark_extension_used usage (Ident.name id) ext1
+ Env.mark_extension_used usage ext1
end;
let ty1 =
Btype.newgenty (Tconstr(ext1.ext_type_path, ext1.ext_type_params, ref Mnil))
let value_descriptions ~loc env ~mark cxt subst id vd1 vd2 =
Cmt_format.record_value_dependency vd1 vd2;
if mark_positive mark then
- Env.mark_value_used (Ident.name id) vd1;
+ Env.mark_value_used vd1.val_uid;
let vd2 = Subst.value_description subst vd2 in
try
Includecore.value_descriptions ~loc env (Ident.name id) vd1 vd2
let type_declarations ~loc env ~mark ?old_env:_ cxt subst id decl1 decl2 =
let mark = mark_positive mark in
if mark then
- Env.mark_type_used (Ident.name id) decl1;
+ Env.mark_type_used decl1.type_uid;
let decl2 = Subst.type_declaration subst decl2 in
match
Includecore.type_declarations ~loc env ~mark
exception Dont_match
-let may_expand_module_path env path =
- try ignore (Env.find_modtype_expansion path env); true
- with Not_found -> false
-
-let expand_module_path env cxt path =
+let try_expand_modtype_path env path =
try
Env.find_modtype_expansion path env
- with Not_found ->
- raise(Error[cxt, env, Unbound_modtype_path path])
+ with Not_found -> raise Dont_match
let expand_module_alias env cxt path =
try (Env.find_module path env).md_type
with Not_found ->
raise(Error[cxt, env, Unbound_module_path path])
-(*
-let rec normalize_module_path env cxt path =
- match expand_module_alias env cxt path with
- Mty_alias path' -> normalize_module_path env cxt path'
- | _ -> path
-*)
-
(* Extract name, kind and ident from a signature item *)
type field_desc =
Field_value of string
| Field_type of string
+ | Field_exception of string
| Field_typext of string
| Field_module of string
| Field_modtype of string
let kind_of_field_desc = function
| Field_value _ -> "value"
| Field_type _ -> "type"
+ | Field_exception _ -> "exception"
| Field_typext _ -> "extension constructor"
| Field_module _ -> "module"
| Field_modtype _ -> "module type"
let item_ident_name = function
Sig_value(id, d, _) -> (id, d.val_loc, Field_value(Ident.name id))
| Sig_type(id, d, _, _) -> (id, d.type_loc, Field_type(Ident.name id))
- | Sig_typext(id, d, _, _) -> (id, d.ext_loc, Field_typext(Ident.name id))
+ | Sig_typext(id, d, _, _) ->
+ let kind =
+ if Path.same d.ext_type_path Predef.path_exn
+ then Field_exception(Ident.name id)
+ else Field_typext(Ident.name id)
+ in
+ (id, d.ext_loc, kind)
| Sig_module(id, _, d, _, _) -> (id, d.md_loc, Field_module(Ident.name id))
| Sig_modtype(id, d, _) -> (id, d.mtd_loc, Field_modtype(Ident.name id))
| Sig_class(id, d, _, _) -> (id, d.cty_loc, Field_class(Ident.name id))
(* Simplify a structure coercion *)
+let equal_module_paths env p1 subst p2 =
+ Path.same p1 p2
+ || Path.same (Env.normalize_module_path None env p1)
+ (Env.normalize_module_path None env
+ (Subst.module_path subst p2))
+
+let equal_modtype_paths env p1 subst p2 =
+ Path.same p1 p2
+ || Path.same (Env.normalize_modtype_path env p1)
+ (Env.normalize_modtype_path env
+ (Subst.modtype_path subst p2))
+
let simplify_structure_coercion cc id_pos_list =
let rec is_identity_coercion pos = function
| [] ->
and try_modtypes ~loc env ~mark cxt subst mty1 mty2 =
match mty1, mty2 with
- | Mty_alias p1, Mty_alias p2 ->
+ | (Mty_alias p1, Mty_alias p2) ->
if Env.is_functor_arg p2 env then
raise (Error[cxt, env, Invalid_module_alias p2]);
- if not (Path.same p1 p2) then begin
- let p1 = Env.normalize_module_path None env p1
- and p2 = Env.normalize_module_path None env
- (Subst.module_path subst p2)
- in
- if not (Path.same p1 p2) then raise Dont_match
- end;
+ if not (equal_module_paths env p1 subst p2) then
+ raise Dont_match;
Tcoerce_none
- | (Mty_alias p1, _) -> begin
+ | (Mty_alias p1, _) ->
let p1 = try
Env.normalize_module_path (Some Location.none) env p1
with Env.Error (Env.Missing_module (_, _, path)) ->
raise (Error[cxt, env, Unbound_module_path path])
in
- let mty1 =
- Mtype.strengthen ~aliasable:true env
- (expand_module_alias env cxt p1) p1
- in
- modtypes ~loc env ~mark cxt subst mty1 mty2
- end
- | (Mty_ident p1, _) when may_expand_module_path env p1 ->
+ let mty1 = expand_module_alias env cxt p1 in
+ strengthened_modtypes ~loc ~aliasable:true env ~mark cxt
+ subst mty1 p1 mty2
+ | (Mty_ident p1, Mty_ident p2) ->
+ let p1 = Env.normalize_modtype_path env p1 in
+ let p2 = Env.normalize_modtype_path env (Subst.modtype_path subst p2) in
+ if Path.same p1 p2 then Tcoerce_none
+ else
+ try_modtypes ~loc env ~mark cxt subst
+ (try_expand_modtype_path env p1)
+ (try_expand_modtype_path env p2)
+ | (Mty_ident p1, _) ->
+ let p1 = Env.normalize_modtype_path env p1 in
try_modtypes ~loc env ~mark cxt subst
- (expand_module_path env cxt p1) mty2
- | (_, Mty_ident _) ->
- try_modtypes2 ~loc env ~mark cxt mty1 (Subst.modtype Keep subst mty2)
+ (try_expand_modtype_path env p1) mty2
+ | (_, Mty_ident p2) ->
+ let p2 = Env.normalize_modtype_path env (Subst.modtype_path subst p2) in
+ try_modtypes ~loc env ~mark cxt subst mty1
+ (try_expand_modtype_path env p2)
| (Mty_signature sig1, Mty_signature sig2) ->
signatures ~loc env ~mark cxt subst sig1 sig2
| (Mty_functor(Unit, res1), Mty_functor(Unit, res2)) ->
| (_, _) ->
raise Dont_match
-and try_modtypes2 ~loc env ~mark cxt mty1 mty2 =
- (* mty2 is an identifier *)
- match (mty1, mty2) with
- (Mty_ident p1, Mty_ident p2)
- when Path.same (Env.normalize_path_prefix None env p1)
- (Env.normalize_path_prefix None env p2) ->
+and strengthened_modtypes ~loc ~aliasable env ~mark cxt subst mty1 path1 mty2 =
+ match mty1, mty2 with
+ | Mty_ident p1, Mty_ident p2 when equal_modtype_paths env p1 subst p2 ->
Tcoerce_none
- | (_, Mty_ident p2) when may_expand_module_path env p2 ->
- try_modtypes ~loc env ~mark cxt Subst.identity
- mty1 (expand_module_path env cxt p2)
- | (_, _) ->
- raise Dont_match
+ | _, _ ->
+ let mty1 = Mtype.strengthen ~aliasable env mty1 path1 in
+ modtypes ~loc env ~mark cxt subst mty1 mty2
+
+and strengthened_module_decl ~loc ~aliasable env ~mark cxt subst md1 path1 md2 =
+ match md1.md_type, md2.md_type with
+ | Mty_ident p1, Mty_ident p2 when equal_modtype_paths env p1 subst p2 ->
+ Tcoerce_none
+ | _, _ ->
+ let md1 = Mtype.strengthen_decl ~aliasable env md1 path1 in
+ modtypes ~loc env ~mark cxt subst md1.md_type md2.md_type
(* Inclusion between signatures *)
(Ident.name id1);
let p1 = Path.Pident id1 in
if mark_positive mark then
- Env.mark_module_used (Ident.name id1) md1.md_loc;
- modtypes ~loc env ~mark (Module id1::cxt) subst
- (Mtype.strengthen ~aliasable:true env md1.md_type p1) md2.md_type
+ Env.mark_module_used md1.md_uid;
+ strengthened_modtypes ~loc ~aliasable:true env ~mark (Module id1::cxt) subst
+ md1.md_type p1 md2.md_type
(* Inclusion between module type specifications *)
let check_modtype_inclusion ~loc env mty1 path1 mty2 =
let aliasable = can_alias env path1 in
- ignore(modtypes ~loc env ~mark:Mark_both [] Subst.identity
- (Mtype.strengthen ~aliasable env mty1 path1) mty2)
+ ignore
+ (strengthened_modtypes ~loc ~aliasable env ~mark:Mark_both []
+ Subst.identity mty1 path1 mty2)
let () =
Env.check_functor_application :=
(* Check that an implementation of a compilation unit meets its
interface. *)
-let compunit env ?(mark=Mark_both) impl_name impl_sig intf_name intf_sig =
+let compunit env ~mark impl_name impl_sig intf_name intf_sig =
try
signatures ~loc:(Location.in_file impl_name) env ~mark []
Subst.identity impl_sig intf_sig
(* Hide the context and substitution parameters to the outside world *)
-let modtypes ~loc env ?(mark=Mark_both) mty1 mty2 =
+let modtypes ~loc env ~mark mty1 mty2 =
modtypes ~loc env ~mark [] Subst.identity mty1 mty2
-let signatures env ?(mark=Mark_both) sig1 sig2 =
+let signatures env ~mark sig1 sig2 =
signatures ~loc:Location.none env ~mark [] Subst.identity sig1 sig2
-let type_declarations ~loc env ?(mark=Mark_both) id decl1 decl2 =
+let type_declarations ~loc env ~mark id decl1 decl2 =
type_declarations ~loc env ~mark [] Subst.identity id decl1 decl2
+let strengthened_module_decl ~loc ~aliasable env ~mark
+ md1 path1 md2 =
+ strengthened_module_decl ~loc ~aliasable env ~mark [] Subst.identity
+ md1 path1 md2
(*
let modtypes env m1 m2 =
(** Do not mark definitions used from either argument *)
val modtypes:
- loc:Location.t -> Env.t -> ?mark:mark ->
+ loc:Location.t -> Env.t -> mark:mark ->
module_type -> module_type -> module_coercion
+val strengthened_module_decl:
+ loc:Location.t -> aliasable:bool -> Env.t -> mark:mark ->
+ module_declaration -> Path.t -> module_declaration -> module_coercion
+
val check_modtype_inclusion :
loc:Location.t -> Env.t -> Types.module_type -> Path.t -> Types.module_type ->
unit
functor application F(M) is well typed, where mty2 is the type of
the argument of F and path1/mty1 is the path/unstrenghened type of M. *)
-val signatures: Env.t -> ?mark:mark ->
+val signatures: Env.t -> mark:mark ->
signature -> signature -> module_coercion
val compunit:
- Env.t -> ?mark:mark -> string -> signature ->
+ Env.t -> mark:mark -> string -> signature ->
string -> signature -> module_coercion
val type_declarations:
- loc:Location.t -> Env.t -> ?mark:mark ->
+ loc:Location.t -> Env.t -> mark:mark ->
Ident.t -> type_declaration -> type_declaration -> unit
val print_coercion: formatter -> module_coercion -> unit
with Ctype.Nondep_cannot_erase _ as exn ->
match va with
Co -> Sig_modtype(id, {mtd_type=None; mtd_loc=Location.none;
- mtd_attributes=[]}, vis)
+ mtd_attributes=[]; mtd_uid = d.mtd_uid}, vis)
| _ -> raise exn
end
| Sig_class(id, d, rs, vis) ->
decl
else
let orig_ty =
- Ctype.reify_univars
+ Ctype.reify_univars env
(Btype.newgenty(Tconstr(p, orig_decl.type_params, ref Mnil)))
in
let new_ty =
- Ctype.reify_univars
+ Ctype.reify_univars env
(Btype.newgenty(Tconstr(Pident id, decl.type_params, ref Mnil)))
in
let env = Env.add_type ~check:false id decl env in
| Tpat_lazy p ->
Lazy, [p]
| Tpat_or _ -> invalid_arg "Parmatch.Pattern_head.deconstruct: (P | Q)"
- | Tpat_exception _ ->
- invalid_arg "Parmatch.Pattern_head.deconstruct: (exception P)"
in
let desc, pats = deconstruct_desc q.pat_desc in
{ desc; typ = q.pat_type; loc = q.pat_loc;
match x,y with
| Const_float f1, Const_float f2 ->
Stdlib.compare (float_of_string f1) (float_of_string f2)
- | Const_string (s1, _), Const_string (s2, _) ->
+ | Const_string (s1, _, _), Const_string (s2, _, _) ->
String.compare s1 s2
| (Const_int _
|Const_char _
- |Const_string (_, _)
+ |Const_string (_, _, _)
|Const_float _
|Const_int32 _
|Const_int64 _
(* build a pattern from a constructor description *)
let pat_of_constr ex_pat cstr =
{ex_pat with pat_desc =
- Tpat_construct (mknoloc (Longident.Lident "?pat_of_constr?"),
+ Tpat_construct (mknoloc (Longident.Lident cstr.cstr_name),
cstr, omegas cstr.cstr_arity)}
let orify x y = make_pat (Tpat_or (x, y, None)) x.pat_type x.pat_env
match ty'.desc with
| Tconstr (path, _, _) ->
begin try match (Env.find_type path env).type_kind with
- | Type_variant cl when always || List.length cl = 1 ||
+ | Type_variant cl when always || List.length cl <= 1 ||
+ (* Only explode when all constructors are GADTs *)
List.for_all (fun cd -> cd.Types.cd_res <> None) cl ->
let cstrs = fst (Env.find_type_descrs path env) in
List.map (pat_of_constr (make_pat Tpat_any ty env)) cstrs
let labels = snd (Env.find_type_descrs path env) in
let fields =
List.map (fun ld ->
- mknoloc (Longident.Lident "?pat_of_label?"), ld, omega)
+ mknoloc (Longident.Lident ld.lbl_name), ld, omega)
labels
in
[make_pat (Tpat_record (fields, Closed)) ty env]
0n Nativeint.succ d env
| Constant Const_string _ ->
build_other_constant
- (function Constant(Const_string (s, _)) -> String.length s
+ (function Constant(Const_string (s, _, _)) -> String.length s
| _ -> assert false)
- (function i -> Tpat_constant(Const_string(String.make i '*', None)))
+ (function i ->
+ Tpat_constant
+ (Const_string(String.make i '*',Location.none,None)))
0 succ d env
| Constant Const_float _ ->
build_other_constant
| Tpat_record (lps,_) -> has_instances (List.map (fun (_,_,x) -> x) lps)
| Tpat_lazy p
-> has_instance p
- | Tpat_exception _ -> assert false
-
and has_instances = function
| [] -> true
(* Apply pressure to variants *)
let pressure_variants tdefs patl =
+ ignore (pressure_variants
+ (Some tdefs)
+ (List.map (fun p -> [p; omega]) patl))
+
+let pressure_variants_in_computation_pattern tdefs patl =
let add_row pss p_opt =
match p_opt with
| None -> pss
- | Some p -> [p; omega] :: pss
+ | Some p -> p :: pss
in
let val_pss, exn_pss =
List.fold_right (fun pat (vpss, epss)->
add_row vpss vp, add_row epss ep
) patl ([], [])
in
- ignore (pressure_variants (Some tdefs) val_pss);
- ignore (pressure_variants (Some tdefs) exn_pss)
+ pressure_variants tdefs val_pss;
+ pressure_variants tdefs exn_pss
(*****************************)
(* Utilities for diagnostics *)
mkpat (Ppat_array (List.map loop lst))
| Tpat_lazy p ->
mkpat (Ppat_lazy (loop p))
- | Tpat_exception _ ->
- assert false
in
let ps = loop typed in
(ps, constrs, labels)
| _ -> false)
pat
-(* Build an untyped or-pattern from its expected type *)
+(* Build a pattern from its expected type *)
+type pat_explosion = PE_single | PE_gadt_cases
+type ppat_of_type =
+ | PT_empty
+ | PT_any
+ | PT_pattern of
+ pat_explosion *
+ Parsetree.pattern *
+ (string, constructor_description) Hashtbl.t *
+ (string, label_description) Hashtbl.t
+
let ppat_of_type env ty =
match pats_of_type env ty with
- | [] -> raise Empty
- | [{pat_desc = Tpat_any}] ->
- (Conv.mkpat Parsetree.Ppat_any, Hashtbl.create 0, Hashtbl.create 0)
+ | [] -> PT_empty
+ | [{pat_desc = Tpat_any}] -> PT_any
+ | [pat] ->
+ let (ppat, constrs, labels) = Conv.conv pat in
+ PT_pattern (PE_single, ppat, constrs, labels)
| pats ->
- Conv.conv (orify_many pats)
+ let (ppat, constrs, labels) = Conv.conv (orify_many pats) in
+ PT_pattern (PE_gadt_cases, ppat, constrs, labels)
let do_check_partial ~pred loc casel pss = match pss with
| [] ->
| Tpat_lazy p
->
collect_paths_from_pat r p
-| Tpat_exception _ -> assert false
(*
ldps
| Tpat_or (p,q,_) ->
loop p && loop q
- | Tpat_exception _ -> assert false
in
loop pat
end
val omega_list : 'a list -> pattern list
(** [List.map (fun _ -> omega)] *)
+module Pattern_head : sig
+ type desc =
+ | Any
+ | Construct of constructor_description
+ | Constant of constant
+ | Tuple of int
+ | Record of label_description list
+ | Variant of
+ { tag: label; has_arg: bool;
+ cstr_row: row_desc ref;
+ type_row : unit -> row_desc; }
+ (* the row of the type may evolve if [close_variant] is called,
+ hence the (unit -> ...) delay *)
+ | Array of int
+ | Lazy
+
+ type t
+
+ val desc : t -> desc
+ val env : t -> Env.t
+ val loc : t -> Location.t
+ val typ : t -> Types.type_expr
+
+ (** [deconstruct p] returns the head of [p] and the list of sub patterns.
+
+ @raises [Invalid_arg _] if [p] is an or- or an exception-pattern. *)
+ val deconstruct : pattern -> t * pattern list
+
+ (** reconstructs a pattern, putting wildcards as sub-patterns. *)
+ val to_omega_pattern : t -> pattern
+
+ val make
+ : loc:Location.t
+ -> typ:Types.type_expr
+ -> env:Env.t
+ -> desc
+ -> t
+
+ val omega : t
+
+end
+
val normalize_pat : pattern -> pattern
(** Keep only the "head" of a pattern: all arguments are replaced by [omega], so
are variables. *)
val complete_constrs :
pattern -> constructor_tag list -> constructor_description list
-(** [ppat_of_type] builds an untyped or-pattern from its expected type.
- May raise [Empty] when [type_expr] is an empty variant *)
-val ppat_of_type :
- Env.t -> type_expr ->
- Parsetree.pattern *
- (string, constructor_description) Hashtbl.t *
- (string, label_description) Hashtbl.t
+(** [ppat_of_type] builds an untyped pattern from its expected type,
+ for explosion of wildcard patterns in Typecore.type_pat.
-val pressure_variants: Env.t -> pattern list -> unit
+ There are four interesting cases:
+ - the type is empty ([PT_empty])
+ - no further explosion is necessary ([PT_any])
+ - a single pattern is generated, from a record or tuple type
+ or a single-variant type ([PE_single])
+ - an or-pattern is generated, in the case that all branches
+ are GADT constructors ([PE_gadt_cases]).
+ *)
+type pat_explosion = PE_single | PE_gadt_cases
+type ppat_of_type =
+ | PT_empty
+ | PT_any
+ | PT_pattern of
+ pat_explosion *
+ Parsetree.pattern *
+ (string, constructor_description) Hashtbl.t *
+ (string, label_description) Hashtbl.t
+
+val ppat_of_type: Env.t -> type_expr -> ppat_of_type
+
+val pressure_variants:
+ Env.t -> pattern list -> unit
+val pressure_variants_in_computation_pattern:
+ Env.t -> computation general_pattern list -> unit
(** [check_partial pred loc caselist] and [check_unused refute pred caselist]
are called with a function [pred] which will be given counter-example
((string, constructor_description) Hashtbl.t ->
(string, label_description) Hashtbl.t ->
Parsetree.pattern -> pattern option) ->
- Location.t -> case list -> partial
+ Location.t -> value case list -> partial
val check_unused:
(bool ->
(string, constructor_description) Hashtbl.t ->
(string, label_description) Hashtbl.t ->
Parsetree.pattern -> pattern option) ->
- case list -> unit
+ value case list -> unit
(* Irrefutability tests *)
val irrefutable : pattern -> bool
val inactive : partial:partial -> pattern -> bool
(* Ambiguous bindings *)
-val check_ambiguous_bindings : case list -> unit
+val check_ambiguous_bindings : value case list -> unit
(* The tag used for open polymorphic variant types with an abstract row *)
val some_private_tag : label
let add_import {imported_units; _} s =
imported_units := String.Set.add s !imported_units
-let add_imported_opaque {imported_opaque_units; _} s =
+let register_import_as_opaque {imported_opaque_units; _} s =
imported_opaque_units := String.Set.add s !imported_opaque_units
let find_in_cache {persistent_structures; _} s =
let check_consistency penv ps =
try import_crcs penv ~source:ps.ps_filename ps.ps_crcs
- with Consistbl.Inconsistency(name, source, auth) ->
+ with Consistbl.Inconsistency {
+ unit_name = name;
+ inconsistent_source = source;
+ original_source = auth;
+ } ->
error (Inconsistent_import(name, auth, source))
let can_load_cmis penv =
| Rectypes -> ()
| Alerts _ -> ()
| Unsafe_string -> ()
- | Opaque -> add_imported_opaque penv modname)
+ | Opaque -> register_import_as_opaque penv modname)
ps.ps_flags;
Consistbl.set crc_units modname crc ps.ps_filename;
add_import penv modname
if Config.safe_string then
error (Depend_on_unsafe_string_unit(ps.ps_name));
| Alerts _ -> ()
- | Opaque -> add_imported_opaque penv modname)
+ | Opaque -> register_import_as_opaque penv modname)
ps.ps_flags;
if check then check_consistency penv ps;
let {persistent_structures; _} = penv in
in [penv] as an opaque module *)
val is_imported_opaque : 'a t -> modname -> bool
+(* [register_import_as_opaque penv md] registers [md] in [penv] as an
+ opaque module *)
+val register_import_as_opaque : 'a t -> modname -> unit
+
val make_cmi : 'a t -> modname -> Types.signature -> alerts
-> Cmi_format.cmi_infos
and path_assert_failure = Pident ident_assert_failure
and path_undefined_recursive_module = Pident ident_undefined_recursive_module
-let decl_abstr =
- {type_params = [];
- type_arity = 0;
- type_kind = Type_abstract;
- type_loc = Location.none;
- type_private = Asttypes.Public;
- type_manifest = None;
- type_variance = [];
- type_is_newtype = false;
- type_expansion_scope = lowest_level;
- type_attributes = [];
- type_immediate = Unknown;
- type_unboxed = unboxed_false_default_false;
- }
-
-let decl_abstr_imm = {decl_abstr with type_immediate = Always}
-
let cstr id args =
{
cd_id = id;
cd_res = None;
cd_loc = Location.none;
cd_attributes = [];
+ cd_uid = Uid.of_predef_id id;
}
let ident_false = ident_create "false"
and ident_cons = ident_create "::"
and ident_none = ident_create "None"
and ident_some = ident_create "Some"
-let common_initial_env add_type add_extension empty_env =
- let decl_bool =
- {decl_abstr with
- type_kind = Type_variant([cstr ident_false []; cstr ident_true []]);
- type_immediate = Always}
- and decl_unit =
- {decl_abstr with
- type_kind = Type_variant([cstr ident_void []]);
- type_immediate = Always}
- and decl_exn =
- {decl_abstr with
- type_kind = Type_open}
- and decl_array =
- let tvar = newgenvar() in
- {decl_abstr with
- type_params = [tvar];
- type_arity = 1;
- type_variance = [Variance.full]}
- and decl_list =
- let tvar = newgenvar() in
- {decl_abstr with
- type_params = [tvar];
- type_arity = 1;
- type_kind =
- Type_variant([cstr ident_nil []; cstr ident_cons [tvar; type_list tvar]]);
- type_variance = [Variance.covariant]}
- and decl_option =
- let tvar = newgenvar() in
- {decl_abstr with
- type_params = [tvar];
- type_arity = 1;
- type_kind = Type_variant([cstr ident_none []; cstr ident_some [tvar]]);
- type_variance = [Variance.covariant]}
- and decl_lazy_t =
- let tvar = newgenvar() in
- {decl_abstr with
- type_params = [tvar];
- type_arity = 1;
- type_variance = [Variance.covariant]}
+
+let mk_add_type add_type type_ident
+ ?manifest ?(immediate=Type_immediacy.Unknown) ?(kind=Type_abstract) env =
+ let decl =
+ {type_params = [];
+ type_arity = 0;
+ type_kind = kind;
+ type_loc = Location.none;
+ type_private = Asttypes.Public;
+ type_manifest = manifest;
+ type_variance = [];
+ type_separability = [];
+ type_is_newtype = false;
+ type_expansion_scope = lowest_level;
+ type_attributes = [];
+ type_immediate = immediate;
+ type_unboxed = unboxed_false_default_false;
+ type_uid = Uid.of_predef_id type_ident;
+ }
in
+ add_type type_ident decl env
+let common_initial_env add_type add_extension empty_env =
+ let add_type = mk_add_type add_type
+ and add_type1 type_ident
+ ~variance ~separability ?(kind=fun _ -> Type_abstract) env =
+ let param = newgenvar () in
+ let decl =
+ {type_params = [param];
+ type_arity = 1;
+ type_kind = kind param;
+ type_loc = Location.none;
+ type_private = Asttypes.Public;
+ type_manifest = None;
+ type_variance = [variance];
+ type_separability = [separability];
+ type_is_newtype = false;
+ type_expansion_scope = lowest_level;
+ type_attributes = [];
+ type_immediate = Unknown;
+ type_unboxed = unboxed_false_default_false;
+ type_uid = Uid.of_predef_id type_ident;
+ }
+ in
+ add_type type_ident decl env
+ in
let add_extension id l =
add_extension id
{ ext_type_path = path_exn;
ext_loc = Location.none;
ext_attributes = [Ast_helper.Attr.mk
(Location.mknoloc "ocaml.warn_on_literal_pattern")
- (Parsetree.PStr [])] }
+ (Parsetree.PStr [])];
+ ext_uid = Uid.of_predef_id id;
+ }
in
add_extension ident_match_failure
[newgenty (Ttuple[type_string; type_int; type_int])] (
[newgenty (Ttuple[type_string; type_int; type_int])] (
add_extension ident_undefined_recursive_module
[newgenty (Ttuple[type_string; type_int; type_int])] (
- add_type ident_int64 decl_abstr (
- add_type ident_int32 decl_abstr (
- add_type ident_nativeint decl_abstr (
- add_type ident_lazy_t decl_lazy_t (
- add_type ident_option decl_option (
- add_type ident_list decl_list (
- add_type ident_array decl_array (
- add_type ident_exn decl_exn (
- add_type ident_unit decl_unit (
- add_type ident_bool decl_bool (
- add_type ident_float decl_abstr (
- add_type ident_string decl_abstr (
- add_type ident_char decl_abstr_imm (
- add_type ident_int decl_abstr_imm (
- add_type ident_extension_constructor decl_abstr (
- add_type ident_floatarray decl_abstr (
+ add_type ident_int64 (
+ add_type ident_int32 (
+ add_type ident_nativeint (
+ add_type1 ident_lazy_t ~variance:Variance.covariant
+ ~separability:Separability.Ind (
+ add_type1 ident_option ~variance:Variance.covariant
+ ~separability:Separability.Ind
+ ~kind:(fun tvar ->
+ Type_variant([cstr ident_none []; cstr ident_some [tvar]])
+ ) (
+ add_type1 ident_list ~variance:Variance.covariant
+ ~separability:Separability.Ind
+ ~kind:(fun tvar ->
+ Type_variant([cstr ident_nil []; cstr ident_cons [tvar; type_list tvar]])
+ ) (
+ add_type1 ident_array ~variance:Variance.full ~separability:Separability.Ind (
+ add_type ident_exn ~kind:Type_open (
+ add_type ident_unit ~immediate:Always
+ ~kind:(Type_variant([cstr ident_void []])) (
+ add_type ident_bool ~immediate:Always
+ ~kind:(Type_variant([cstr ident_false []; cstr ident_true []])) (
+ add_type ident_float (
+ add_type ident_string (
+ add_type ident_char ~immediate:Always (
+ add_type ident_int ~immediate:Always (
+ add_type ident_extension_constructor (
+ add_type ident_floatarray (
empty_env))))))))))))))))))))))))))))
let build_initial_env add_type add_exception empty_env =
let common = common_initial_env add_type add_exception empty_env in
- let safe_string = add_type ident_bytes decl_abstr common in
- let decl_bytes_unsafe = {decl_abstr with type_manifest = Some type_string} in
- let unsafe_string = add_type ident_bytes decl_bytes_unsafe common in
+ let add_type = mk_add_type add_type in
+ let safe_string = add_type ident_bytes common in
+ let unsafe_string = add_type ident_bytes ~manifest:type_string common in
(safe_string, unsafe_string)
let builtin_values =
let pretty_const c = match c with
| Const_int i -> Printf.sprintf "%d" i
| Const_char c -> Printf.sprintf "%C" c
-| Const_string (s, _) -> Printf.sprintf "%S" s
+| Const_string (s, _, _) -> Printf.sprintf "%S" s
| Const_float f -> Printf.sprintf "%s" f
| Const_int32 i -> Printf.sprintf "%ldl" i
| Const_int64 i -> Printf.sprintf "%LdL" i
| Const_nativeint i -> Printf.sprintf "%ndn" i
-let rec pretty_val ppf v =
+let pretty_extra ppf (cstr, _loc, _attrs) pretty_rest rest =
+ match cstr with
+ | Tpat_unpack ->
+ fprintf ppf "@[(module %a)@]" pretty_rest rest
+ | Tpat_constraint _ ->
+ fprintf ppf "@[(%a : _)@]" pretty_rest rest
+ | Tpat_type _ ->
+ fprintf ppf "@[(# %a)@]" pretty_rest rest
+ | Tpat_open _ ->
+ fprintf ppf "@[(# %a)@]" pretty_rest rest
+
+let rec pretty_val : type k . _ -> k general_pattern -> _ = fun ppf v ->
match v.pat_extra with
- (cstr, _loc, _attrs) :: rem ->
- begin match cstr with
- | Tpat_unpack ->
- fprintf ppf "@[(module %a)@]" pretty_val { v with pat_extra = rem }
- | Tpat_constraint _ ->
- fprintf ppf "@[(%a : _)@]" pretty_val { v with pat_extra = rem }
- | Tpat_type _ ->
- fprintf ppf "@[(# %a)@]" pretty_val { v with pat_extra = rem }
- | Tpat_open _ ->
- fprintf ppf "@[(# %a)@]" pretty_val { v with pat_extra = rem }
- end
+ | extra :: rem ->
+ pretty_extra ppf extra
+ pretty_val { v with pat_extra = rem }
| [] ->
match v.pat_desc with
| Tpat_any -> fprintf ppf "_"
fprintf ppf "@[[| %a |]@]" (pretty_vals " ;") vs
| Tpat_lazy v ->
fprintf ppf "@[<2>lazy@ %a@]" pretty_arg v
- | Tpat_exception v ->
- fprintf ppf "@[<2>exception@ %a@]" pretty_arg v
| Tpat_alias (v, x,_) ->
fprintf ppf "@[(%a@ as %a)@]" pretty_val v Ident.print x
- | Tpat_or (v,w,_) ->
- fprintf ppf "@[(%a|@,%a)@]" pretty_or v pretty_or w
+ | Tpat_value v ->
+ fprintf ppf "%a" pretty_val (v :> pattern)
+ | Tpat_exception v ->
+ fprintf ppf "@[<2>exception@ %a@]" pretty_arg v
+ | Tpat_or _ ->
+ fprintf ppf "@[(%a)@]" pretty_or v
and pretty_car ppf v = match v.pat_desc with
| Tpat_construct (_,cstr, [_ ; _])
| Tpat_variant (_, Some _, _) -> fprintf ppf "(%a)" pretty_val v
| _ -> pretty_val ppf v
-and pretty_or ppf v = match v.pat_desc with
-| Tpat_or (v,w,_) ->
- fprintf ppf "%a|@,%a" pretty_or v pretty_or w
-| _ -> pretty_val ppf v
+and pretty_or : type k . _ -> k general_pattern -> _ = fun ppf v ->
+ match v.pat_desc with
+ | Tpat_or (v,w,_) ->
+ fprintf ppf "%a|@,%a" pretty_or v pretty_or w
+ | _ -> pretty_val ppf v
and pretty_vals sep ppf = function
| [] -> ()
let top_pretty ppf v =
fprintf ppf "@[%a@]@?" pretty_val v
-
let pretty_pat p =
top_pretty Format.str_formatter p ;
prerr_string (Format.flush_str_formatter ())
-type matrix = pattern list list
+type 'k matrix = 'k general_pattern list list
let pretty_line fmt =
List.iter (fun p ->
Format.fprintf fmt ">";
)
-let pretty_matrix fmt (pss : matrix) =
+let pretty_matrix fmt (pss : 'k matrix) =
Format.fprintf fmt "begin matrix\n" ;
List.iter (fun ps ->
pretty_line fmt ps ;
-val pretty_const : Asttypes.constant -> string
-val top_pretty : Format.formatter -> Typedtree.pattern -> unit
-val pretty_pat : Typedtree.pattern -> unit
-val pretty_line : Format.formatter -> Typedtree.pattern list -> unit
-val pretty_matrix : Format.formatter -> Typedtree.pattern list list -> unit
+val pretty_const
+ : Asttypes.constant -> string
+val top_pretty
+ : Format.formatter -> 'k Typedtree.general_pattern -> unit
+val pretty_pat
+ : 'k Typedtree.general_pattern -> unit
+val pretty_line
+ : Format.formatter -> 'k Typedtree.general_pattern list -> unit
+val pretty_matrix
+ : Format.formatter -> 'k Typedtree.general_pattern list list -> unit
(* printing environment for path shortening and naming *)
let printing_env = ref Env.empty
+
+(* When printing, it is important to only observe the
+ current printing environment, without reading any new
+ cmi present on the file system *)
+let in_printing_env f = Env.without_cmis f !printing_env
+
let human_unique n id = Printf.sprintf "%s/%d" (Ident.name id) n
type namespace =
let pp ppf x = Format.pp_print_string ppf (show x)
+ (** The two functions below should never access the filesystem,
+ and thus use {!in_printing_env} rather than directly
+ accessing the printing environment *)
let lookup =
- let to_lookup f lid =
- fst @@ f (Lident lid) !printing_env
- in
+ let to_lookup f lid = fst @@ in_printing_env (f (Lident lid)) in
function
| Type -> to_lookup Env.find_type_by_name
| Module -> to_lookup Env.find_module_by_name
| Other -> fun _ -> raise Not_found
let location namespace id =
- let env = !printing_env in
let path = Path.Pident id in
try Some (
match namespace with
- | Type -> (Env.find_type path env).type_loc
- | Module -> (Env.find_module path env).md_loc
- | Module_type -> (Env.find_modtype path env).mtd_loc
- | Class -> (Env.find_class path env).cty_loc
- | Class_type -> (Env.find_cltype path env).clty_loc
+ | Type -> (in_printing_env @@ Env.find_type path).type_loc
+ | Module -> (in_printing_env @@ Env.find_module path).md_loc
+ | Module_type -> (in_printing_env @@ Env.find_modtype path).mtd_loc
+ | Class -> (in_printing_env @@ Env.find_class path).cty_loc
+ | Class_type -> (in_printing_env @@ Env.find_cltype path).clty_loc
| Other -> Location.none
) with Not_found -> None
let non_shadowed_pervasive = function
| Pdot(Pident id, s) as path ->
Ident.same id ident_stdlib &&
- (match Env.find_type_by_name (Lident s) !printing_env with
+ (match in_printing_env (Env.find_type_by_name (Lident s)) with
| (path', _) -> Path.same path path'
| exception Not_found -> true)
| _ -> false
let name_gen = if non_gen then new_weak_name ty else new_name in
Otyp_var (non_gen, name_of_type name_gen ty)
| Tarrow(l, ty1, ty2, _) ->
- let pr_arrow l ty1 ty2 =
- let lab =
- if !print_labels || is_optional l then string_of_label l else ""
- in
- let t1 =
- if is_optional l then
- match (repr ty1).desc with
- | Tconstr(path, [ty], _)
- when Path.same path Predef.path_option ->
- tree_of_typexp sch ty
- | _ -> Otyp_stuff "<hidden>"
- else tree_of_typexp sch ty1 in
- Otyp_arrow (lab, t1, tree_of_typexp sch ty2) in
- pr_arrow l ty1 ty2
+ let lab =
+ if !print_labels || is_optional l then string_of_label l else ""
+ in
+ let t1 =
+ if is_optional l then
+ match (repr ty1).desc with
+ | Tconstr(path, [ty], _)
+ when Path.same path Predef.path_option ->
+ tree_of_typexp sch ty
+ | _ -> Otyp_stuff "<hidden>"
+ else tree_of_typexp sch ty1 in
+ Otyp_arrow (lab, t1, tree_of_typexp sch ty2)
| Ttuple tyl ->
Otyp_tuple (tree_of_typlist sch tyl)
| Tconstr(p, tyl, _abbrev) ->
and type_scheme ppf ty = reset_and_mark_loops ty; typexp true ppf ty
+let type_path ppf p =
+ let (p', s) = best_type_path p in
+ let p = if (s = Id) then p' else p in
+ let t = tree_of_path Type p in
+ !Oprint.out_ident ppf t
+
(* Maxence *)
let type_scheme_max ?(b_reset_names=true) ppf ty =
if b_reset_names then reset_names () ;
([], rem)
let dummy =
- { type_params = []; type_arity = 0; type_kind = Type_abstract;
- type_private = Public; type_manifest = None; type_variance = [];
- type_is_newtype = false; type_expansion_scope = Btype.lowest_level;
+ {
+ type_params = [];
+ type_arity = 0;
+ type_kind = Type_abstract;
+ type_private = Public;
+ type_manifest = None;
+ type_variance = [];
+ type_separability = [];
+ type_is_newtype = false;
+ type_expansion_scope = Btype.lowest_level;
type_loc = Location.none;
type_attributes = [];
type_immediate = Unknown;
type_unboxed = unboxed_false_default_false;
+ type_uid = Uid.internal_not_actually_unique;
}
let hide ids env = List.fold_right
val path: formatter -> Path.t -> unit
val string_of_path: Path.t -> string
+val type_path: formatter -> Path.t -> unit
+(** Print a type path taking account of [-short-paths].
+ Calls should be within [wrap_printing_env]. *)
+
module Out_name: sig
val create: string -> out_name
val print: out_name -> string
val reset: unit -> unit
end
-
val reset: unit -> unit
val mark_loops: type_expr -> unit
val reset_and_mark_loops: type_expr -> unit
;;
let fmt_location f loc =
- fprintf f "(%a..%a)" fmt_position loc.loc_start fmt_position loc.loc_end;
- if loc.loc_ghost then fprintf f " ghost";
+ if not !Clflags.locations then ()
+ else begin
+ fprintf f "(%a..%a)" fmt_position loc.loc_start fmt_position loc.loc_end;
+ if loc.loc_ghost then fprintf f " ghost";
+ end
;;
let rec fmt_longident_aux f x =
match x with
| Const_int (i) -> fprintf f "Const_int %d" i;
| Const_char (c) -> fprintf f "Const_char %02x" (Char.code c);
- | Const_string (s, None) -> fprintf f "Const_string(%S,None)" s;
- | Const_string (s, Some delim) ->
- fprintf f "Const_string (%S,Some %S)" s delim;
+ | Const_string (s, strloc, None) ->
+ fprintf f "Const_string(%S,%a,None)" s fmt_location strloc;
+ | Const_string (s, strloc, Some delim) ->
+ fprintf f "Const_string (%S,%a,Some %S)" s fmt_location strloc delim;
| Const_float (s) -> fprintf f "Const_float %s" s;
| Const_int32 (i) -> fprintf f "Const_int32 %ld" i;
| Const_int64 (i) -> fprintf f "Const_int64 %Ld" i;
line i ppf "with type %a\n" fmt_longident s;
core_type i ppf t
-and pattern i ppf x =
+and pattern : type k . _ -> _ -> k general_pattern -> unit = fun i ppf x ->
line i ppf "pattern %a\n" fmt_location x.pat_loc;
attributes i ppf x.pat_attributes;
let i = i+1 in
match x.pat_extra with
- | (Tpat_unpack, _, attrs) :: rem ->
- line i ppf "Tpat_unpack\n";
- attributes i ppf attrs;
- pattern i ppf { x with pat_extra = rem }
- | (Tpat_constraint cty, _, attrs) :: rem ->
- line i ppf "Tpat_constraint\n";
- attributes i ppf attrs;
- core_type i ppf cty;
- pattern i ppf { x with pat_extra = rem }
- | (Tpat_type (id, _), _, attrs) :: rem ->
- line i ppf "Tpat_type %a\n" fmt_path id;
- attributes i ppf attrs;
- pattern i ppf { x with pat_extra = rem }
- | (Tpat_open (id,_,_), _, attrs)::rem ->
- line i ppf "Tpat_open \"%a\"\n" fmt_path id;
- attributes i ppf attrs;
+ | extra :: rem ->
+ pattern_extra i ppf extra;
pattern i ppf { x with pat_extra = rem }
| [] ->
match x.pat_desc with
| Tpat_array (l) ->
line i ppf "Tpat_array\n";
list i pattern ppf l;
- | Tpat_or (p1, p2, _) ->
- line i ppf "Tpat_or\n";
- pattern i ppf p1;
- pattern i ppf p2;
| Tpat_lazy p ->
line i ppf "Tpat_lazy\n";
pattern i ppf p;
| Tpat_exception p ->
line i ppf "Tpat_exception\n";
pattern i ppf p;
+ | Tpat_value p ->
+ line i ppf "Tpat_value\n";
+ pattern i ppf (p :> pattern);
+ | Tpat_or (p1, p2, _) ->
+ line i ppf "Tpat_or\n";
+ pattern i ppf p1;
+ pattern i ppf p2;
+
+and pattern_extra i ppf (extra_pat, _, attrs) =
+ match extra_pat with
+ | Tpat_unpack ->
+ line i ppf "Tpat_extra_unpack\n";
+ attributes i ppf attrs;
+ | Tpat_constraint cty ->
+ line i ppf "Tpat_extra_constraint\n";
+ attributes i ppf attrs;
+ core_type i ppf cty;
+ | Tpat_type (id, _) ->
+ line i ppf "Tpat_extra_type %a\n" fmt_path id;
+ attributes i ppf attrs;
+ | Tpat_open (id,_,_) ->
+ line i ppf "Tpat_extra_open \"%a\"\n" fmt_path id;
+ attributes i ppf attrs;
and expression_extra i ppf x attrs =
match x with
line i ppf "%a\n" fmt_longident li;
pattern (i+1) ppf p;
-and case i ppf {c_lhs; c_guard; c_rhs} =
+and case
+ : type k . _ -> _ -> k case -> unit
+ = fun i ppf {c_lhs; c_guard; c_rhs} ->
line i ppf "<case>\n";
pattern (i+1) ppf c_lhs;
begin match c_guard with
]
| Texp_override (pth, fields) ->
(*
- G |- pth : m (Gi |- ei : m[Derefence])^i
+ G |- pth : m (Gi |- ei : m[Dereference])^i
----------------------------------------------------
G + sum(Gi)^i |- {< (xi = ei)^i >} (at path pth) : m
m' is the mode under which the scrutinee of p
(the value matched against p) is placed.
*)
-and case : Typedtree.case -> mode -> Env.t * mode =
- fun { Typedtree.c_lhs; c_guard; c_rhs } ->
+and case
+ : 'k . 'k Typedtree.case -> mode -> Env.t * mode
+ = fun { Typedtree.c_lhs; c_guard; c_rhs } ->
(*
Ge |- e : m Gg |- g : m[Dereference]
G := Ge+Gg p : mp -| G
m is the mode under which the scrutinee of p is placed.
*)
-and pattern : pattern -> Env.t -> mode = fun pat env ->
+and pattern : type k . k general_pattern -> Env.t -> mode = fun pat env ->
(*
mp := | Dereference if p is destructuring
| Guard otherwise
in
Mode.join m_pat m_env
-and is_destructuring_pattern : Typedtree.pattern -> bool =
+and is_destructuring_pattern : type k . k general_pattern -> bool =
fun pat -> match pat.pat_desc with
| Tpat_any -> false
| Tpat_var (_, _) -> false
| Tpat_variant _ -> true
| Tpat_record (_, _) -> true
| Tpat_array _ -> true
- | Tpat_or (l,r,_) ->
- is_destructuring_pattern l || is_destructuring_pattern r
| Tpat_lazy _ -> true
+ | Tpat_value pat -> is_destructuring_pattern (pat :> pattern)
| Tpat_exception _ -> false
+ | Tpat_or (l,r,_) ->
+ is_destructuring_pattern l || is_destructuring_pattern r
let is_valid_recursive_expression idlist expr =
let ty = expression expr Return in
let output_int oc i = output_string oc (Int.to_string i)
type annotation =
- | Ti_pat of pattern
+ | Ti_pat : 'k pattern_category * 'k general_pattern -> annotation
| Ti_expr of expression
| Ti_class of class_expr
| Ti_mod of module_expr
let get_location ti =
match ti with
- Ti_pat p -> p.pat_loc
+ | Ti_pat (_, p) -> p.pat_loc
| Ti_expr e -> e.exp_loc
| Ti_class c -> c.cl_loc
| Ti_mod m -> m.mod_loc
let print_info pp prev_loc ti =
match ti with
| Ti_class _ | Ti_mod _ -> prev_loc
- | Ti_pat {pat_loc = loc; pat_type = typ; pat_env = env}
- | Ti_expr {exp_loc = loc; exp_type = typ; exp_env = env} ->
+ | Ti_pat (_, {pat_loc = loc; pat_type = typ; pat_env = env})
+ | Ti_expr {exp_loc = loc; exp_type = typ; exp_env = env} ->
if loc <> prev_loc then begin
print_location pp loc;
output_char pp '\n'
open Typedtree;;
type annotation =
- | Ti_pat of pattern
+ | Ti_pat : 'k pattern_category * 'k general_pattern -> annotation
| Ti_expr of expression
| Ti_class of class_expr
| Ti_mod of module_expr
| exception Not_found -> Tconstr(type_path s p, args, ref Mnil)
| Path _ -> Tconstr(type_path s p, args, ref Mnil)
| Type_function { params; body } ->
- (!ctype_apply_env_empty params body args).desc
+ Tlink (!ctype_apply_env_empty params body args)
end
| Tpackage(p, n, tl) ->
Tpackage(modtype_path s p, n, List.map (typexp copy_scope s) tl)
ld_type = typexp copy_scope s l.ld_type;
ld_loc = loc s l.ld_loc;
ld_attributes = attrs s l.ld_attributes;
+ ld_uid = l.ld_uid;
}
let constructor_arguments copy_scope s = function
cd_res = Option.map (typexp copy_scope s) c.cd_res;
cd_loc = loc s c.cd_loc;
cd_attributes = attrs s c.cd_attributes;
+ cd_uid = c.cd_uid;
}
let type_declaration' copy_scope s decl =
end;
type_private = decl.type_private;
type_variance = decl.type_variance;
+ type_separability = decl.type_separability;
type_is_newtype = false;
type_expansion_scope = Btype.lowest_level;
type_loc = loc s decl.type_loc;
type_attributes = attrs s decl.type_attributes;
type_immediate = decl.type_immediate;
type_unboxed = decl.type_unboxed;
+ type_uid = decl.type_uid;
}
let type_declaration s decl =
end;
cty_loc = loc s decl.cty_loc;
cty_attributes = attrs s decl.cty_attributes;
+ cty_uid = decl.cty_uid;
}
let class_declaration s decl =
clty_path = type_path s decl.clty_path;
clty_loc = loc s decl.clty_loc;
clty_attributes = attrs s decl.clty_attributes;
+ clty_uid = decl.clty_uid;
}
let cltype_declaration s decl =
val_kind = descr.val_kind;
val_loc = loc s descr.val_loc;
val_attributes = attrs s descr.val_attributes;
+ val_uid = descr.val_uid;
}
let value_description s descr =
ext_ret_type = Option.map (typexp copy_scope s) ext.ext_ret_type;
ext_private = ext.ext_private;
ext_attributes = attrs s ext.ext_attributes;
- ext_loc = if s.for_saving then Location.none else ext.ext_loc; }
+ ext_loc = if s.for_saving then Location.none else ext.ext_loc;
+ ext_uid = ext.ext_uid;
+ }
let extension_constructor s ext =
For_copy.with_scope
| Sig_class_type(id, d, rs, vis) ->
Sig_class_type(id, cltype_declaration' copy_scope s d, rs, vis)
-and signature_item s comp =
- For_copy.with_scope (fun copy_scope -> signature_item' copy_scope s comp)
+and signature_item scoping s comp =
+ For_copy.with_scope
+ (fun copy_scope -> signature_item' copy_scope scoping s comp)
and module_declaration scoping s decl =
{
md_type = modtype scoping s decl.md_type;
md_attributes = attrs s decl.md_attributes;
md_loc = loc s decl.md_loc;
+ md_uid = decl.md_uid;
}
and modtype_declaration scoping s decl =
mtd_type = Option.map (modtype scoping s) decl.mtd_type;
mtd_attributes = attrs s decl.mtd_attributes;
mtd_loc = loc s decl.mtd_loc;
+ mtd_uid = decl.mtd_uid;
}
let type_replacement s = function
| Path p -> Path (type_path s p)
| Type_function { params; body } ->
- let params = List.map (type_expr s) params in
- let body = type_expr s body in
- Type_function { params; body }
+ For_copy.with_scope (fun copy_scope ->
+ let params = List.map (typexp copy_scope s) params in
+ let body = typexp copy_scope s body in
+ Type_function { params; body })
(* Composition of substitutions:
apply (compose s1 s2) x = apply s2 (apply s1 x) *)
val module_path: t -> Path.t -> Path.t
val type_path: t -> Path.t -> Path.t
+val modtype_path: t -> Path.t -> Path.t
val type_expr: t -> type_expr -> type_expr
val class_type: t -> class_type -> class_type
type iterator =
{
binding_op: iterator -> binding_op -> unit;
- case: iterator -> case -> unit;
- cases: iterator -> case list -> unit;
+ case: 'k . iterator -> 'k case -> unit;
class_declaration: iterator -> class_declaration -> unit;
class_description: iterator -> class_description -> unit;
class_expr: iterator -> class_expr -> unit;
module_type: iterator -> module_type -> unit;
module_type_declaration: iterator -> module_type_declaration -> unit;
package_type: iterator -> package_type -> unit;
- pat: iterator -> pattern -> unit;
+ pat: 'k . iterator -> 'k general_pattern -> unit;
row_field: iterator -> row_field -> unit;
object_field: iterator -> object_field -> unit;
open_declaration: iterator -> open_declaration -> unit;
Option.iter (sub.typ sub) cto
| Text_rebind _ -> ()
-let pat sub {pat_extra; pat_desc; pat_env; _} =
- let extra = function
- | Tpat_type _ -> ()
- | Tpat_unpack -> ()
- | Tpat_open (_, _, env) -> sub.env sub env
- | Tpat_constraint ct -> sub.typ sub ct
- in
+let pat_extra sub (e, _loc, _attrs) = match e with
+ | Tpat_type _ -> ()
+ | Tpat_unpack -> ()
+ | Tpat_open (_, _, env) -> sub.env sub env
+ | Tpat_constraint ct -> sub.typ sub ct
+
+let pat
+ : type k . iterator -> k general_pattern -> unit
+ = fun sub {pat_extra = extra; pat_desc; pat_env; _} ->
sub.env sub pat_env;
- List.iter (fun (e, _, _) -> extra e) pat_extra;
+ List.iter (pat_extra sub) extra;
match pat_desc with
| Tpat_any -> ()
| Tpat_var _ -> ()
| Tpat_variant (_, po, _) -> Option.iter (sub.pat sub) po
| Tpat_record (l, _) -> List.iter (fun (_, _, i) -> sub.pat sub i) l
| Tpat_array l -> List.iter (sub.pat sub) l
- | Tpat_or (p1, p2, _) ->
- sub.pat sub p1;
- sub.pat sub p2
| Tpat_alias (p, _, _) -> sub.pat sub p
| Tpat_lazy p -> sub.pat sub p
+ | Tpat_value p -> sub.pat sub (p :> pattern)
| Tpat_exception p -> sub.pat sub p
+ | Tpat_or (p1, p2, _) ->
+ sub.pat sub p1;
+ sub.pat sub p2
let expr sub {exp_extra; exp_desc; exp_env; _} =
let extra = function
| Texp_let (rec_flag, list, exp) ->
sub.value_bindings sub (rec_flag, list);
sub.expr sub exp
- | Texp_function {cases; _} -> sub.cases sub cases
+ | Texp_function {cases; _} ->
+ List.iter (sub.case sub) cases
| Texp_apply (exp, list) ->
sub.expr sub exp;
List.iter (fun (_, o) -> Option.iter (sub.expr sub) o) list
| Texp_match (exp, cases, _) ->
sub.expr sub exp;
- sub.cases sub cases
+ List.iter (sub.case sub) cases
| Texp_try (exp, cases) ->
sub.expr sub exp;
- sub.cases sub cases
+ List.iter (sub.case sub) cases
| Texp_tuple list -> List.iter (sub.expr sub) list
| Texp_construct (_, _, args) -> List.iter (sub.expr sub) args
| Texp_variant (_, expo) -> Option.iter (sub.expr sub) expo
let value_bindings sub (_, list) = List.iter (sub.value_binding sub) list
-let cases sub l = List.iter (sub.case sub) l
-
let case sub {c_lhs; c_guard; c_rhs} =
sub.pat sub c_lhs;
Option.iter (sub.expr sub) c_guard;
{
binding_op;
case;
- cases;
class_declaration;
class_description;
class_expr;
type iterator =
{
binding_op: iterator -> binding_op -> unit;
- case: iterator -> case -> unit;
- cases: iterator -> case list -> unit;
+ case: 'k . iterator -> 'k case -> unit;
class_declaration: iterator -> class_declaration -> unit;
class_description: iterator -> class_description -> unit;
class_expr: iterator -> class_expr -> unit;
module_type: iterator -> module_type -> unit;
module_type_declaration: iterator -> module_type_declaration -> unit;
package_type: iterator -> package_type -> unit;
- pat: iterator -> pattern -> unit;
+ pat: 'k . iterator -> 'k general_pattern -> unit;
row_field: iterator -> row_field -> unit;
object_field: iterator -> object_field -> unit;
open_declaration: iterator -> open_declaration -> unit;
type mapper =
{
binding_op: mapper -> binding_op -> binding_op;
- case: mapper -> case -> case;
- cases: mapper -> case list -> case list;
+ case: 'k . mapper -> 'k case -> 'k case;
class_declaration: mapper -> class_declaration -> class_declaration;
class_description: mapper -> class_description -> class_description;
class_expr: mapper -> class_expr -> class_expr;
module_type_declaration:
mapper -> module_type_declaration -> module_type_declaration;
package_type: mapper -> package_type -> package_type;
- pat: mapper -> pattern -> pattern;
+ pat: 'k . mapper -> 'k general_pattern -> 'k general_pattern;
row_field: mapper -> row_field -> row_field;
object_field: mapper -> object_field -> object_field;
open_declaration: mapper -> open_declaration -> open_declaration;
in
{x with ext_kind}
-let pat sub x =
- let extra = function
- | Tpat_type _
- | Tpat_unpack as d -> d
- | Tpat_open (path,loc,env) -> Tpat_open (path, loc, sub.env sub env)
- | Tpat_constraint ct -> Tpat_constraint (sub.typ sub ct)
- in
+let pat_extra sub = function
+ | Tpat_type _
+ | Tpat_unpack as d -> d
+ | Tpat_open (path,loc,env) -> Tpat_open (path, loc, sub.env sub env)
+ | Tpat_constraint ct -> Tpat_constraint (sub.typ sub ct)
+
+let pat
+ : type k . mapper -> k general_pattern -> k general_pattern
+ = fun sub x ->
let pat_env = sub.env sub x.pat_env in
- let pat_extra = List.map (tuple3 extra id id) x.pat_extra in
- let pat_desc =
+ let pat_extra = List.map (tuple3 (pat_extra sub) id id) x.pat_extra in
+ let pat_desc : k pattern_desc =
match x.pat_desc with
| Tpat_any
| Tpat_var _
- | Tpat_constant _ as d -> d
+ | Tpat_constant _ -> x.pat_desc
| Tpat_tuple l -> Tpat_tuple (List.map (sub.pat sub) l)
| Tpat_construct (loc, cd, l) ->
Tpat_construct (loc, cd, List.map (sub.pat sub) l)
| Tpat_record (l, closed) ->
Tpat_record (List.map (tuple3 id id (sub.pat sub)) l, closed)
| Tpat_array l -> Tpat_array (List.map (sub.pat sub) l)
- | Tpat_or (p1, p2, rd) ->
- Tpat_or (sub.pat sub p1, sub.pat sub p2, rd)
| Tpat_alias (p, id, s) -> Tpat_alias (sub.pat sub p, id, s)
| Tpat_lazy p -> Tpat_lazy (sub.pat sub p)
- | Tpat_exception p -> Tpat_exception (sub.pat sub p)
+ | Tpat_value p ->
+ (as_computation_pattern (sub.pat sub (p :> pattern))).pat_desc
+ | Tpat_exception p ->
+ Tpat_exception (sub.pat sub p)
+ | Tpat_or (p1, p2, rd) ->
+ Tpat_or (sub.pat sub p1, sub.pat sub p2, rd)
in
{x with pat_extra; pat_desc; pat_env}
let (rec_flag, list) = sub.value_bindings sub (rec_flag, list) in
Texp_let (rec_flag, list, sub.expr sub exp)
| Texp_function { arg_label; param; cases; partial; } ->
- Texp_function { arg_label; param; cases = sub.cases sub cases;
- partial; }
+ let cases = List.map (sub.case sub) cases in
+ Texp_function { arg_label; param; cases; partial; }
| Texp_apply (exp, list) ->
Texp_apply (
sub.expr sub exp,
| Texp_match (exp, cases, p) ->
Texp_match (
sub.expr sub exp,
- sub.cases sub cases,
+ List.map (sub.case sub) cases,
p
)
| Texp_try (exp, cases) ->
Texp_try (
sub.expr sub exp,
- sub.cases sub cases
+ List.map (sub.case sub) cases
)
| Texp_tuple list ->
Texp_tuple (List.map (sub.expr sub) list)
let value_bindings sub (rec_flag, list) =
(rec_flag, List.map (sub.value_binding sub) list)
-let cases sub l =
- List.map (sub.case sub) l
-
-let case sub {c_lhs; c_guard; c_rhs} =
+let case
+ : type k . mapper -> k case -> k case
+ = fun sub {c_lhs; c_guard; c_rhs} ->
{
c_lhs = sub.pat sub c_lhs;
c_guard = Option.map (sub.expr sub) c_guard;
{
binding_op;
case;
- cases;
class_declaration;
class_description;
class_expr;
type mapper =
{
binding_op: mapper -> binding_op -> binding_op;
- case: mapper -> case -> case;
- cases: mapper -> case list -> case list;
+ case: 'k . mapper -> 'k case -> 'k case;
class_declaration: mapper -> class_declaration -> class_declaration;
class_description: mapper -> class_description -> class_description;
class_expr: mapper -> class_expr -> class_expr;
module_type_declaration:
mapper -> module_type_declaration -> module_type_declaration;
package_type: mapper -> package_type -> package_type;
- pat: mapper -> pattern -> pattern;
+ pat: 'k . mapper -> 'k general_pattern -> 'k general_pattern;
row_field: mapper -> row_field -> row_field;
object_field: mapper -> object_field -> object_field;
open_declaration: mapper -> open_declaration -> open_declaration;
req: 'a Typedtree.class_infos;
}
+type class_env = { val_env : Env.t; met_env : Env.t; par_env : Env.t }
+
type error =
Unconsistent_constraint of Ctype.Unification_trace.t
| Field_type_mismatch of string * string * Ctype.Unification_trace.t
(* Record a class type *)
let rc node =
Cmt_format.add_saved_type (Cmt_format.Partial_class_expr node);
- Stypes.record (Stypes.Ti_class node); (* moved to genannot *)
node
(* Enter a value in the method environment only *)
-let enter_met_env ?check loc lab kind unbound_kind ty val_env met_env par_env =
+let enter_met_env ?check loc lab kind unbound_kind ty class_env =
+ let {val_env; met_env; par_env} = class_env in
let val_env = Env.enter_unbound_value lab unbound_kind val_env in
let par_env = Env.enter_unbound_value lab unbound_kind par_env in
let (id, met_env) =
Env.enter_value ?check lab
{val_type = ty; val_kind = kind;
- val_attributes = []; Types.val_loc = loc} met_env
+ val_attributes = []; Types.val_loc = loc;
+ val_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); } met_env
in
- (id, val_env, met_env, par_env)
+ let class_env = {val_env; met_env; par_env} in
+ (id,class_env )
(* Enter an instance variable in the environment *)
-let enter_val cl_num vars inh lab mut virt ty val_env met_env par_env loc =
+let enter_val cl_num vars inh lab mut virt ty class_env loc =
+ let val_env = class_env.val_env in
let (id, virt) =
try
let (id, mut', virt', ty') = Vars.find lab !vars in
Field_type_mismatch("instance variable", lab, tr)))
| Not_found -> None, virt
in
- let (id, _, _, _) as result =
- match id with Some id -> (id, val_env, met_env, par_env)
+ let (id, _) as result =
+ match id with Some id -> (id, class_env)
| None ->
enter_met_env Location.none lab (Val_ivar (mut, cl_num))
- Val_unbound_instance_variable ty val_env met_env par_env
+ Val_unbound_instance_variable ty class_env
in
vars := Vars.add lab (id, mut, virt, ty) !vars;
result
(fun () -> class_field_aux self_loc cl_num self_type meths vars arg cf)
and class_field_aux self_loc cl_num self_type meths vars
- (val_env, met_env, par_env, fields, concr_meths, warn_vals, inher,
+ (class_env, fields, concr_meths, warn_vals, inher,
local_meths, local_vals) cf =
let loc = cf.pcf_loc in
let mkcf desc =
{ cf_desc = desc; cf_loc = loc; cf_attributes = cf.pcf_attributes }
in
+ let {val_env; met_env; par_env} = class_env in
match cf.pcf_desc with
Pcf_inherit (ovf, sparent, super) ->
let parent = class_expr cl_num val_env par_env sparent in
sparent.pcl_loc parent.cl_type
in
(* Variables *)
- let (val_env, met_env, par_env, inh_vars) =
+ let (class_env, inh_vars) =
Vars.fold
- (fun lab info (val_env, met_env, par_env, inh_vars) ->
+ (fun lab info (class_env, inh_vars) ->
let mut, vr, ty = info in
- let (id, val_env, met_env, par_env) =
- enter_val cl_num vars true lab mut vr ty val_env met_env par_env
- sparent.pcl_loc
+ let (id, class_env) =
+ enter_val cl_num vars true lab mut vr ty class_env
+ sparent.pcl_loc ;
in
- (val_env, met_env, par_env, (lab, id) :: inh_vars))
- cl_sig.csig_vars (val_env, met_env, par_env, [])
+ (class_env, (lab, id) :: inh_vars))
+ cl_sig.csig_vars (class_env, [])
in
(* Inherited concrete methods *)
let inh_meths =
cl_sig.csig_concr []
in
(* Super *)
- let (val_env, met_env, par_env,super) =
+ let (class_env,super) =
match super with
None ->
- (val_env, met_env, par_env,None)
+ (class_env,None)
| Some {txt=name} ->
- let (_id, val_env, met_env, par_env) =
+ let (_id, class_env) =
enter_met_env ~check:(fun s -> Warnings.Unused_ancestor s)
sparent.pcl_loc name (Val_anc (inh_meths, cl_num))
- Val_unbound_ancestor self_type val_env met_env par_env
+ Val_unbound_ancestor self_type class_env
in
- (val_env, met_env, par_env,Some name)
+ (class_env,Some name)
in
- (val_env, met_env, par_env,
+ (class_env,
lazy (mkcf (Tcf_inherit (ovf, parent, super, inh_vars, inh_meths)))
:: fields,
concr_meths, warn_vals, inher, local_meths, local_vals)
Ctype.end_def ();
Ctype.generalize_structure ty
end;
- let (id, val_env, met_env', par_env) =
+ let (id, class_env') =
enter_val cl_num vars false lab.txt mut Virtual ty
- val_env met_env par_env loc
+ class_env loc
in
- (val_env, met_env', par_env,
+ (class_env',
lazy (mkcf (Tcf_val (lab, mut, id, Tcfk_virtual cty,
- met_env == met_env')))
+ met_env == class_env'.met_env)))
:: fields,
concr_meths, warn_vals, inher, local_meths, local_vals)
Ctype.end_def ();
Ctype.generalize_structure exp.exp_type
end;
- let (id, val_env, met_env', par_env) =
+ let (id, class_env') =
enter_val cl_num vars false lab.txt mut Concrete exp.exp_type
- val_env met_env par_env loc
+ class_env loc
in
- (val_env, met_env', par_env,
+ (class_env',
lazy (mkcf (Tcf_val (lab, mut, id,
- Tcfk_concrete (ovf, exp), met_env == met_env')))
+ Tcfk_concrete (ovf, exp), met_env == class_env'.met_env)))
:: fields,
concr_meths, Concr.add lab.txt warn_vals, inher, local_meths,
Concr.add lab.txt local_vals)
| Pcf_method (lab, priv, Cfk_virtual sty) ->
let cty = virtual_method val_env meths self_type lab.txt priv sty loc in
- (val_env, met_env, par_env,
+ (class_env,
lazy (mkcf(Tcf_method (lab, priv, Tcfk_virtual cty)))
::fields,
concr_meths, warn_vals, inher, local_meths, local_vals)
mkcf (Tcf_method (lab, priv, Tcfk_concrete (ovf, texp)))
)
in
- (val_env, met_env, par_env, field::fields,
+ (class_env, field::fields,
Concr.add lab.txt concr_meths, warn_vals, inher,
Concr.add lab.txt local_meths, local_vals)
| Pcf_constraint (sty, sty') ->
let (cty, cty') = type_constraint val_env sty sty' loc in
- (val_env, met_env, par_env,
+ (class_env,
lazy (mkcf (Tcf_constraint (cty, cty'))) :: fields,
concr_meths, warn_vals, inher, local_meths, local_vals)
Ctype.end_def ();
mkcf (Tcf_initializer texp)
end in
- (val_env, met_env, par_env, field::fields, concr_meths, warn_vals,
+ (class_env, field::fields, concr_meths, warn_vals,
inher, local_meths, local_vals)
| Pcf_attribute x ->
Builtin_attributes.warning_attribute x;
- (val_env, met_env, par_env,
+ (class_env,
lazy (mkcf (Tcf_attribute x)) :: fields,
concr_meths, warn_vals, inher, local_meths, local_vals)
| Pcf_extension ext ->
let private_self = if final then Ctype.newvar () else self_type in
(* Self binder *)
- let (pat, meths, vars, val_env, meth_env, par_env) =
+ let (pat, meths, vars, val_env, met_env, par_env) =
type_self_pattern cl_num private_self val_env met_env par_env spat
in
let public_self = pat.pat_type in
end;
(* Typing of class fields *)
- let (_, _, _, fields, concr_meths, _, inher, _local_meths, _local_vals) =
+ let class_env = {val_env; met_env; par_env} in
+ let (_, fields, concr_meths, _, inher, _local_meths, _local_vals) =
Builtin_attributes.warning_scope []
(fun () ->
List.fold_left (class_field self_loc cl_num self_type meths vars)
- (val_env, meth_env, par_env, [], Concr.empty, Concr.empty, [],
+ ( class_env,[], Concr.empty, Concr.empty, [],
Concr.empty, Concr.empty)
str
)
in
if !Clflags.principal then begin
Ctype.end_def ();
- iter_pattern (fun {pat_type=ty} -> Ctype.generalize_structure ty) pat
+ let gen {pat_type = ty} = Ctype.generalize_structure ty in
+ iter_pattern gen pat
end;
let pv =
List.map
true
end
in
- let rec type_args args omitted ty_fun ty_fun0 sargs more_sargs =
+ let rec type_args args omitted ty_fun ty_fun0 sargs =
match ty_fun, ty_fun0 with
| Cty_arrow (l, ty, ty_fun), Cty_arrow (_, ty0, ty_fun0)
- when sargs <> [] || more_sargs <> [] ->
+ when sargs <> [] ->
let name = Btype.label_name l
and optional = Btype.is_optional l in
- let sargs, more_sargs, arg =
- if ignore_labels && not (Btype.is_optional l) then begin
- match sargs, more_sargs with
- (l', sarg0)::_, _ ->
- raise(Error(sarg0.pexp_loc, val_env, Apply_wrong_label l'))
- | _, (l', sarg0)::more_sargs ->
- if l <> l' && l' <> Nolabel then
- raise(Error(sarg0.pexp_loc, val_env,
- Apply_wrong_label l'))
- else ([], more_sargs,
- Some (type_argument val_env sarg0 ty ty0))
- | _ ->
- assert false
- end else try
- let (l', sarg0, sargs, more_sargs) =
- try
- let (l', sarg0, sargs1, sargs2) =
- Btype.extract_label name sargs
- in (l', sarg0, sargs1 @ sargs2, more_sargs)
- with Not_found ->
- let (l', sarg0, sargs1, sargs2) =
- Btype.extract_label name more_sargs
- in (l', sarg0, sargs @ sargs1, sargs2)
- in
- if not optional && Btype.is_optional l' then
- Location.prerr_warning sarg0.pexp_loc
- (Warnings.Nonoptional_label (Printtyp.string_of_label l));
- sargs, more_sargs,
+ let use_arg sarg l' =
+ Some (
if not optional || Btype.is_optional l' then
- Some (type_argument val_env sarg0 ty ty0)
+ type_argument val_env sarg ty ty0
else
let ty' = extract_option_type val_env ty
and ty0' = extract_option_type val_env ty0 in
- let arg = type_argument val_env sarg0 ty' ty0' in
- Some (option_some val_env arg)
- with Not_found ->
- sargs, more_sargs,
- if Btype.is_optional l
- && (List.mem_assoc Nolabel sargs
- || List.mem_assoc Nolabel more_sargs)
- then
- Some (option_none val_env ty0 Location.none)
- else None
+ let arg = type_argument val_env sarg ty' ty0' in
+ option_some val_env arg
+ )
+ in
+ let eliminate_optional_arg () =
+ Some (option_none val_env ty0 Location.none)
+ in
+ let remaining_sargs, arg =
+ if ignore_labels then begin
+ match sargs with
+ | [] -> assert false
+ | (l', sarg) :: remaining_sargs ->
+ if name = Btype.label_name l' ||
+ (not optional && l' = Nolabel)
+ then
+ (remaining_sargs, use_arg sarg l')
+ else if
+ optional &&
+ not (List.exists (fun (l, _) -> name = Btype.label_name l)
+ remaining_sargs)
+ then
+ (sargs, eliminate_optional_arg ())
+ else
+ raise(Error(sarg.pexp_loc, val_env, Apply_wrong_label l'))
+ end else
+ match Btype.extract_label name sargs with
+ | Some (l', sarg, _, remaining_sargs) ->
+ if not optional && Btype.is_optional l' then
+ Location.prerr_warning sarg.pexp_loc
+ (Warnings.Nonoptional_label
+ (Printtyp.string_of_label l));
+ remaining_sargs, use_arg sarg l'
+ | None ->
+ sargs,
+ if Btype.is_optional l && List.mem_assoc Nolabel sargs then
+ eliminate_optional_arg ()
+ else
+ None
in
let omitted = if arg = None then (l,ty0) :: omitted else omitted in
- type_args ((l,arg)::args) omitted ty_fun ty_fun0
- sargs more_sargs
+ type_args ((l,arg)::args) omitted ty_fun ty_fun0 remaining_sargs
| _ ->
- match sargs @ more_sargs with
+ match sargs with
(l, sarg0)::_ ->
if omitted <> [] then
raise(Error(sarg0.pexp_loc, val_env, Apply_wrong_label l))
in
let (args, cty) =
let (_, ty_fun0) = Ctype.instance_class [] cl.cl_type in
- if ignore_labels then
- type_args [] [] cl.cl_type ty_fun0 [] sargs
- else
- type_args [] [] cl.cl_type ty_fun0 sargs []
+ type_args [] [] cl.cl_type ty_fun0 sargs
in
rc {cl_desc = Tcl_apply (cl, args);
cl_loc = scl.pcl_loc;
cl_num);
val_attributes = [];
Types.val_loc = vd.Types.val_loc;
+ val_uid = vd.val_uid;
}
in
let id' = Ident.create_local (Ident.name id) in
(*******************************)
-let temp_abbrev loc env id arity =
+let temp_abbrev loc env id arity uid =
let params = ref [] in
for _i = 1 to arity do
params := Ctype.newvar () :: !params
type_private = Public;
type_manifest = Some ty;
type_variance = Misc.replicate_list Variance.full arity;
+ type_separability = Types.Separability.default_signature ~arity;
type_is_newtype = false;
type_expansion_scope = Btype.lowest_level;
type_loc = loc;
type_attributes = []; (* or keep attrs from the class decl? *)
type_immediate = Unknown;
type_unboxed = unboxed_false_default_false;
+ type_uid = uid;
}
env
in
(!params, ty, env)
let initial_env define_class approx
- (res, env) (cl, id, ty_id, obj_id, cl_id) =
+ (res, env) (cl, id, ty_id, obj_id, cl_id, uid) =
(* Temporary abbreviations *)
let arity = List.length cl.pci_params in
- let (obj_params, obj_ty, env) = temp_abbrev cl.pci_loc env obj_id arity in
- let (cl_params, cl_ty, env) = temp_abbrev cl.pci_loc env cl_id arity in
+ let (obj_params, obj_ty, env) = temp_abbrev cl.pci_loc env obj_id arity uid in
+ let (cl_params, cl_ty, env) = temp_abbrev cl.pci_loc env cl_id arity uid in
(* Temporary type for the class constructor *)
let constr_type = approx cl.pci_expr in
end;
cty_loc = Location.none;
cty_attributes = [];
+ cty_uid = uid;
}
in
let env =
clty_path = unbound_class;
clty_loc = Location.none;
clty_attributes = [];
+ clty_uid = uid;
}
(
if define_class then
clty_path = Path.Pident obj_id;
clty_loc = cl.pci_loc;
clty_attributes = cl.pci_attributes;
+ clty_uid = dummy_class.cty_uid;
}
and clty =
{cty_params = params; cty_type = typ;
end;
cty_loc = cl.pci_loc;
cty_attributes = cl.pci_attributes;
+ cty_uid = dummy_class.cty_uid;
}
in
dummy_class.cty_type <- typ;
clty_path = Path.Pident obj_id;
clty_loc = cl.pci_loc;
clty_attributes = cl.pci_attributes;
+ clty_uid = dummy_class.cty_uid;
}
and clty =
{cty_params = params'; cty_type = typ';
end;
cty_loc = cl.pci_loc;
cty_attributes = cl.pci_attributes;
+ cty_uid = dummy_class.cty_uid;
}
in
let obj_abbr =
- {type_params = obj_params;
- type_arity = List.length obj_params;
+ let arity = List.length obj_params in
+ {
+ type_params = obj_params;
+ type_arity = arity;
type_kind = Type_abstract;
type_private = Public;
type_manifest = Some obj_ty;
type_variance = List.map (fun _ -> Variance.full) obj_params;
+ type_separability = Types.Separability.default_signature ~arity;
type_is_newtype = false;
type_expansion_scope = Btype.lowest_level;
type_loc = cl.pci_loc;
type_attributes = []; (* or keep attrs from cl? *)
type_immediate = Unknown;
type_unboxed = unboxed_false_default_false;
+ type_uid = dummy_class.cty_uid;
}
in
let (cl_params, cl_ty) =
Ctype.hide_private_methods cl_ty;
Ctype.set_object_name obj_id (Ctype.row_variable cl_ty) cl_params cl_ty;
let cl_abbr =
- {type_params = cl_params;
- type_arity = List.length cl_params;
+ let arity = List.length cl_params in
+ {
+ type_params = cl_params;
+ type_arity = arity;
type_kind = Type_abstract;
type_private = Public;
type_manifest = Some cl_ty;
type_variance = List.map (fun _ -> Variance.full) cl_params;
+ type_separability = Types.Separability.default_signature ~arity;
type_is_newtype = false;
type_expansion_scope = Btype.lowest_level;
type_loc = cl.pci_loc;
type_attributes = []; (* or keep attrs from cl? *)
type_immediate = Unknown;
type_unboxed = unboxed_false_default_false;
+ type_uid = dummy_class.cty_uid;
}
in
((cl, id, clty, ty_id, cltydef, obj_id, obj_abbr, cl_id, cl_abbr, ci_params,
Ident.create_scoped ~scope cl.pci_name.txt,
Ident.create_scoped ~scope cl.pci_name.txt,
Ident.create_scoped ~scope cl.pci_name.txt,
- Ident.create_scoped ~scope ("#" ^ cl.pci_name.txt)))
+ Ident.create_scoped ~scope ("#" ^ cl.pci_name.txt),
+ Uid.mk ~current_unit:(Env.get_unit_name ())
+ ))
cls
in
Ctype.begin_class_def ();
explanation: type_forcing_context option;
}
+module Datatype_kind = struct
+ type t = Record | Variant
+
+ let type_name = function
+ | Record -> "record"
+ | Variant -> "variant"
+
+ let label_name = function
+ | Record -> "field"
+ | Variant -> "constructor"
+end
+
+type wrong_name = {
+ type_path: Path.t;
+ kind: Datatype_kind.t;
+ name: string loc;
+ valid_names: string list;
+}
+
type existential_restriction =
| At_toplevel (** no existential types at the toplevel *)
| In_group (** nor with let ... and ... *)
type error =
| Constructor_arity_mismatch of Longident.t * int * int
| Label_mismatch of Longident.t * Ctype.Unification_trace.t
- | Pattern_type_clash of Ctype.Unification_trace.t * pattern_desc option
+ | Pattern_type_clash :
+ Ctype.Unification_trace.t * _ pattern_desc option -> error
| Or_pattern_type_clash of Ident.t * Ctype.Unification_trace.t
| Multiply_bound_variable of string
| Orpat_vars of Ident.t * Ident.t list
Ctype.Unification_trace.t * type_forcing_context option
* expression_desc option
| Apply_non_function of type_expr
- | Apply_wrong_label of arg_label * type_expr
+ | Apply_wrong_label of arg_label * type_expr * bool
| Label_multiply_defined of string
| Label_missing of Ident.t list
| Label_not_mutable of Longident.t
- | Wrong_name of
- string * type_expected * string * Path.t * string * string list
+ | Wrong_name of string * type_expected * wrong_name
| Name_type_mismatch of
- string * Longident.t * (Path.t * Path.t) * (Path.t * Path.t) list
+ Datatype_kind.t * Longident.t * (Path.t * Path.t) * (Path.t * Path.t) list
| Invalid_format of string
| Undefined_method of type_expr * string * string list option
| Undefined_inherited_method of string * string list
| Illegal_letrec_pat
| Illegal_letrec_expr
| Illegal_class_expr
- | Empty_pattern
| Letop_type_clash of string * Ctype.Unification_trace.t
| Andop_type_clash of string * Ctype.Unification_trace.t
| Bindings_type_clash of Ctype.Unification_trace.t
*)
let re node =
Cmt_format.add_saved_type (Cmt_format.Partial_expression node);
- Stypes.record (Stypes.Ti_expr node);
node
;;
let rp node =
- Cmt_format.add_saved_type (Cmt_format.Partial_pattern node);
- Stypes.record (Stypes.Ti_pat node);
+ Cmt_format.add_saved_type (Cmt_format.Partial_pattern (Value, node));
+ node
+;;
+let rcp node =
+ Cmt_format.add_saved_type (Cmt_format.Partial_pattern (Computation, node));
node
;;
end
| Pconst_integer (i,Some c) -> Error (Unknown_literal (i, c))
| Pconst_char c -> Ok (Const_char c)
- | Pconst_string (s,d) -> Ok (Const_string (s,d))
+ | Pconst_string (s,loc,d) -> Ok (Const_string (s,loc,d))
| Pconst_float (f,None)-> Ok (Const_float f)
| Pconst_float (f,Some c) -> Error (Unknown_literal (f, c))
(* Creating new conjunctive types is not allowed when typing patterns *)
(* make all Reither present in open variants *)
-let finalize_variant pat =
- match pat.pat_desc with
- Tpat_variant(tag, opat, r) ->
- let row =
- match expand_head pat.pat_env pat.pat_type with
- {desc = Tvariant row} -> r := row; row_repr row
- | _ -> assert false
- in
- begin match row_field tag row with
- | Rabsent -> () (* assert false *)
- | Reither (true, [], _, e) when not row.row_closed ->
- set_row_field e (Rpresent None)
- | Reither (false, ty::tl, _, e) when not row.row_closed ->
- set_row_field e (Rpresent (Some ty));
- begin match opat with None -> assert false
- | Some pat ->
- let env = ref pat.pat_env in
- List.iter (unify_pat env pat) (ty::tl)
- end
- | Reither (c, _l, true, e) when not (row_fixed row) ->
- set_row_field e (Reither (c, [], false, ref None))
- | _ -> ()
- end;
- (* Force check of well-formedness WHY? *)
- (* unify_pat pat.pat_env pat
- (newty(Tvariant{row_fields=[]; row_more=newvar(); row_closed=false;
- row_bound=(); row_fixed=false; row_name=None})); *)
+let finalize_variant pat tag opat r =
+ let row =
+ match expand_head pat.pat_env pat.pat_type with
+ {desc = Tvariant row} -> r := row; row_repr row
+ | _ -> assert false
+ in
+ begin match row_field tag row with
+ | Rabsent -> () (* assert false *)
+ | Reither (true, [], _, e) when not row.row_closed ->
+ set_row_field e (Rpresent None)
+ | Reither (false, ty::tl, _, e) when not row.row_closed ->
+ set_row_field e (Rpresent (Some ty));
+ begin match opat with None -> assert false
+ | Some pat ->
+ let env = ref pat.pat_env in List.iter (unify_pat env pat) (ty::tl)
+ end
+ | Reither (c, _l, true, e) when not (row_fixed row) ->
+ set_row_field e (Reither (c, [], false, ref None))
| _ -> ()
+ end
+ (* Force check of well-formedness WHY? *)
+ (* unify_pat pat.pat_env pat
+ (newty(Tvariant{row_fields=[]; row_more=newvar(); row_closed=false;
+ row_bound=(); row_fixed=false; row_name=None})); *)
let has_variants p =
- exists_pattern
- (function {pat_desc=Tpat_variant _} -> true | _ -> false)
- p
+ exists_general_pattern
+ { f = fun (type k) (p : k general_pattern) -> match p.pat_desc with
+ | (Tpat_variant _) -> true
+ | _ -> false } p
+
+let finalize_variants p =
+ iter_general_pattern
+ { f = fun (type k) (p : k general_pattern) -> match p.pat_desc with
+ | Tpat_variant(tag, opat, r) ->
+ finalize_variant p tag opat r
+ | _ -> () } p
(* pattern environment *)
type pattern_variable =
if not !allow_modules then
raise (Error (loc, Env.empty, Modules_not_allowed));
module_variables := (name, loc) :: !module_variables
- end else begin
- (* moved to genannot *)
- Option.iter
- (fun s -> Stypes.record (Stypes.An_ident (name.loc, name.txt, s)))
- !pattern_scope
end;
id
newty (Tvariant{row with row_closed=false; row_more=newvar()})
end
| Tpat_any | Tpat_var _ | Tpat_constant _
- | Tpat_array _ | Tpat_lazy _ | Tpat_exception _ -> p.pat_type
+ | Tpat_array _ | Tpat_lazy _ -> p.pat_type
let build_or_pat env loc lid =
let path, decl = Env.lookup_type ~loc:lid.loc lid.txt env in
Path.same (expand_path env tpath1) (expand_path env tpath2)
(* Records *)
-let label_of_kind kind =
- if kind = "record" then "field" else "constructor"
+exception Wrong_name_disambiguation of Env.t * wrong_name
+
+let get_constr_type_path ty =
+ match (repr ty).desc with
+ | Tconstr(p, _, _) -> p
+ | _ -> assert false
module NameChoice(Name : sig
type t
type usage
- val type_kind: string
+ val kind: Datatype_kind.t
val get_name: t -> string
val get_type: t -> type_expr
val lookup_all_from_type:
Location.t -> usage -> Path.t -> Env.t -> (t * (unit -> unit)) list
+
+ (** Some names (for example the fields of inline records) are not
+ in the typing environment -- they behave as structural labels
+ rather than nominal labels.*)
val in_env: t -> bool
end) = struct
open Name
- let get_type_path d =
- match (repr (get_type d)).desc with
- | Tconstr(p, _, _) -> p
- | _ -> assert false
+ let get_type_path d = get_constr_type_path (get_type d)
- let lookup_from_type env tpath usage lid =
- let descrs = lookup_all_from_type lid.loc usage tpath env in
+ let lookup_from_type env type_path usage lid =
+ let descrs = lookup_all_from_type lid.loc usage type_path env in
match lid.txt with
- | Longident.Lident s -> begin
+ | Longident.Lident name -> begin
match
- List.find (fun (nd, _) -> get_name nd = s) descrs
+ List.find (fun (nd, _) -> get_name nd = name) descrs
with
| descr, use ->
use ();
descr
| exception Not_found ->
- let names = List.map (fun (nd, _) -> get_name nd) descrs in
- raise (Error (lid.loc, env,
- Wrong_name ("", mk_expected (newvar ()),
- type_kind, tpath, s, names)))
+ let valid_names = List.map (fun (nd, _) -> get_name nd) descrs in
+ raise (Wrong_name_disambiguation (env, {
+ type_path;
+ name = { lid with txt = name };
+ kind;
+ valid_names;
+ }))
end
| _ -> raise Not_found
in
List.find check_type lbls
- let disambiguate ?(warn=Location.prerr_warning) ?scope
- usage lid env opath lbls =
- let scope = match scope with None -> lbls | Some l -> l in
- let lbl = match opath with
- None ->
- begin match lbls with
- | (Error(loc', env', err) : _ result) ->
- Env.lookup_error loc' env' err
- | Ok [] -> assert false
+ (* warn if there are several distinct candidates in scope *)
+ let warn_if_ambiguous warn lid env lbl rest =
+ Printtyp.Conflicts.reset ();
+ let paths = ambiguous_types env lbl rest in
+ let expansion =
+ Format.asprintf "%t" Printtyp.Conflicts.print_explanations in
+ if paths <> [] then
+ warn lid.loc
+ (Warnings.Ambiguous_name ([Longident.last lid.txt],
+ paths, false, expansion))
+
+ (* a non-principal type was used for disambiguation *)
+ let warn_non_principal warn lid =
+ let name = Datatype_kind.label_name kind in
+ warn lid.loc
+ (Warnings.Not_principal
+ ("this type-based " ^ name ^ " disambiguation"))
+
+ (* we selected a name out of the lexical scope *)
+ let warn_out_of_scope warn lid env tpath =
+ let path_s =
+ Printtyp.wrap_printing_env ~error:true env
+ (fun () -> Printtyp.string_of_path tpath) in
+ warn lid.loc
+ (Warnings.Name_out_of_scope (path_s, [Longident.last lid.txt], false))
+
+ (* warn if the selected name is not the last introduced in scope
+ -- in these cases the resolution is different from pre-disambiguation OCaml
+ (this warning is not enabled by default, it is specifically for people
+ wishing to write backward-compatible code).
+ *)
+ let warn_if_disambiguated_name warn lid lbl scope =
+ match scope with
+ | Ok ((lab1,_) :: _) when lab1 == lbl -> ()
+ | _ ->
+ warn lid.loc
+ (Warnings.Disambiguated_name (get_name lbl))
+
+ let force_error : ('a, _) result -> 'a = function
+ | Ok lbls -> lbls
+ | Error (loc', env', err) ->
+ Env.lookup_error loc' env' err
+
+ type candidate = t * (unit -> unit)
+ type nonempty_candidate_filter =
+ candidate list -> (candidate list, candidate list) result
+ (** This type is used for candidate filtering functions.
+ Filtering typically proceeds in several passes, filtering
+ candidates through increasingly precise conditions.
+
+ We assume that the input list is non-empty, and the output is one of
+ - [Ok result] for a non-empty list [result] of valid candidates
+ - [Error candidates] with there are no valid candidates,
+ and [candidates] is a non-empty subset of the input, typically
+ the result of the last non-empty filtering step.
+ *)
+
+ (** [disambiguate] selects a concrete description for [lid] using
+ some contextual information:
+ - An optional [expected_type].
+ - A list of candidates labels in the current lexical scope,
+ [candidates_in_scope], that is actually at the type
+ [(label_descr list, lookup_error) result] so that the
+ lookup error is only raised when necessary.
+ - A filtering criterion on candidates in scope [filter_candidates],
+ representing extra contextual information that can help
+ candidate selection (see [disambiguate_label_by_ids]).
+ *)
+ let disambiguate
+ ?(warn=Location.prerr_warning)
+ ?(filter : nonempty_candidate_filter = Result.ok)
+ usage lid env
+ expected_type
+ candidates_in_scope =
+ let lbl = match expected_type with
+ | None ->
+ (* no expected type => no disambiguation *)
+ begin match filter (force_error candidates_in_scope) with
+ | Ok [] | Error [] -> assert false
+ | Error((lbl, _use) :: _rest) -> lbl (* will fail later *)
| Ok((lbl, use) :: rest) ->
use ();
- Printtyp.Conflicts.reset ();
- let paths = ambiguous_types env lbl rest in
- let expansion =
- Format.asprintf "%t" Printtyp.Conflicts.print_explanations in
- if paths <> [] then
- warn lid.loc
- (Warnings.Ambiguous_name ([Longident.last lid.txt],
- paths, false, expansion));
+ warn_if_ambiguous warn lid env lbl rest;
lbl
end
- | Some(tpath0, tpath, pr) ->
- let warn_pr () =
- let label = label_of_kind type_kind in
- warn lid.loc
- (Warnings.Not_principal
- ("this type-based " ^ label ^ " disambiguation"))
- in
- try
- let lbl, use = disambiguate_by_type env tpath scope in
+ | Some(tpath0, tpath, principal) ->
+ (* If [expected_type] is available, the candidate selected
+ will correspond to the type-based resolution.
+ There are two reasons to still check the lexical scope:
+ - for warning purposes
+ - for extension types, the type environment does not contain
+ a list of constructors, so using only type-based selection
+ would fail.
+ *)
+ (* note that [disambiguate_by_type] does not
+ force [candidates_in_scope]: we just skip this case if there
+ are no candidates in scope *)
+ begin match disambiguate_by_type env tpath candidates_in_scope with
+ | lbl, use ->
use ();
- if not pr then begin
+ if not principal then begin
(* Check if non-principal type is affecting result *)
- match lbls with
- | (Error _ : _ result) | Ok [] -> warn_pr ()
+ match (candidates_in_scope : _ result) with
+ | Error _ -> warn_non_principal warn lid
+ | Ok lbls ->
+ match filter lbls with
+ | Error _ -> warn_non_principal warn lid
+ | Ok [] -> assert false
| Ok ((lbl', _use') :: rest) ->
- let lbl_tpath = get_type_path lbl' in
- if not (compare_type_path env tpath lbl_tpath) then warn_pr ()
- else
- Printtyp.Conflicts.reset ();
- let paths = ambiguous_types env lbl rest in
- let expansion =
- Format.asprintf "%t"
- Printtyp.Conflicts.print_explanations in
- if paths <> [] then
- warn lid.loc
- (Warnings.Ambiguous_name ([Longident.last lid.txt],
- paths, false, expansion))
+ let lbl_tpath = get_type_path lbl' in
+ (* no principality warning if the non-principal
+ type-based selection corresponds to the last
+ definition in scope *)
+ if not (compare_type_path env tpath lbl_tpath)
+ then warn_non_principal warn lid
+ else warn_if_ambiguous warn lid env lbl rest;
end;
lbl
- with Not_found -> try
- let lbl = lookup_from_type env tpath usage lid in
- if in_env lbl then
- begin
- let s =
- Printtyp.wrap_printing_env ~error:true env
- (fun () -> Printtyp.string_of_path tpath) in
- warn lid.loc
- (Warnings.Name_out_of_scope (s, [Longident.last lid.txt], false));
- end;
- if not pr then warn_pr ();
+ | exception Not_found ->
+ (* look outside the lexical scope *)
+ match lookup_from_type env tpath usage lid with
+ | lbl ->
+ (* warn only on nominal labels;
+ structural labels cannot be qualified anyway *)
+ if in_env lbl then warn_out_of_scope warn lid env tpath;
+ if not principal then warn_non_principal warn lid;
lbl
- with Not_found ->
- match lbls with
- | (Error(loc', env', err) : _ result) ->
- Env.lookup_error loc' env' err
- | Ok lbls ->
- let tp = (tpath0, expand_path env tpath) in
- let tpl =
- List.map
- (fun (lbl, _) ->
- let tp0 = get_type_path lbl in
- let tp = expand_path env tp0 in
- (tp0, tp))
- lbls
- in
- raise (Error (lid.loc, env,
- Name_type_mismatch (type_kind, lid.txt, tp, tpl)))
+ | exception Not_found ->
+ match filter (force_error candidates_in_scope) with
+ | Ok lbls | Error lbls ->
+ let tp = (tpath0, expand_path env tpath) in
+ let tpl =
+ List.map
+ (fun (lbl, _) ->
+ let tp0 = get_type_path lbl in
+ let tp = expand_path env tp0 in
+ (tp0, tp))
+ lbls
+ in
+ raise (Error (lid.loc, env,
+ Name_type_mismatch (kind, lid.txt, tp, tpl)));
+ end
in
+ (* warn only on nominal labels *)
if in_env lbl then
- begin match scope with
- | Ok ((lab1,_)::_) when lab1 == lbl -> ()
- | _ ->
- Location.prerr_warning lid.loc
- (Warnings.Disambiguated_name(get_name lbl))
- end;
+ warn_if_disambiguated_name warn lid lbl candidates_in_scope;
lbl
end
-let wrap_disambiguate kind ty f x =
- try f x with Error (loc, env, Wrong_name ("",_,tk,tp,name,valid_names)) ->
- raise (Error (loc, env, Wrong_name (kind,ty,tk,tp,name,valid_names)))
+let wrap_disambiguate msg ty f x =
+ try f x with
+ | Wrong_name_disambiguation (env, wrong_name) ->
+ raise (Error (wrong_name.name.loc, env, Wrong_name (msg, ty, wrong_name)))
module Label = NameChoice (struct
type t = label_description
type usage = unit
- let type_kind = "record"
+ let kind = Datatype_kind.Record
let get_name lbl = lbl.lbl_name
let get_type lbl = lbl.lbl_res
let lookup_all_from_type loc () path env =
| Record_unboxed true | Record_inlined _ | Record_extension _ -> false
end)
-let disambiguate_label_by_ids keep closed ids labels =
+(* In record-construction expressions and patterns, we have many labels
+ at once; find a candidate type in the intersection of the candidates
+ of each label. In the [closed] expression case, this candidate must
+ contain exactly all the labels.
+
+ If our successive refinements result in an empty list,
+ return [Error] with the last non-empty list of candidates
+ for use in error messages.
+*)
+let disambiguate_label_by_ids closed ids labels : (_, _) result =
let check_ids (lbl, _) =
let lbls = Hashtbl.create 8 in
Array.iter (fun lbl -> Hashtbl.add lbls lbl.lbl_name ()) lbl.lbl_all;
and check_closed (lbl, _) =
(not closed || List.length ids = Array.length lbl.lbl_all)
in
- let labels' = List.filter check_ids labels in
- if keep && labels' = [] then (false, labels) else
- let labels'' = List.filter check_closed labels' in
- if keep && labels'' = [] then (false, labels') else (true, labels'')
+ match List.filter check_ids labels with
+ | [] -> Error labels
+ | labels ->
+ match List.filter check_closed labels with
+ | [] -> Error labels
+ | labels ->
+ Ok labels
(* Only issue warnings once per record constructor/pattern *)
-let disambiguate_lid_a_list loc closed env opath lid_a_list =
+let disambiguate_lid_a_list loc closed env expected_type lid_a_list =
let ids = List.map (fun (lid, _) -> Longident.last lid.txt) lid_a_list in
let w_pr = ref false and w_amb = ref []
and w_scope = ref [] and w_scope_ty = ref "" in
| _ -> Location.prerr_warning loc msg
in
let process_label lid =
- (* Strategy for each field:
- * collect all the labels in scope for that name
- * if the type is known and principal, just eventually warn
- if the real label was not in scope
- * fail if there is no known type and no label found
- * otherwise use other fields to reduce the list of candidates
- * if there is no known type reduce it incrementally, so that
- there is still at least one candidate (for error message)
- * if the reduced list is valid, call Label.disambiguate
- *)
let scope = Env.lookup_all_labels ~loc:lid.loc lid.txt env in
- match opath, scope with
- | None, Error(loc, env, err) ->
- Env.lookup_error loc env err
- | Some _, Error _ ->
- Label.disambiguate () lid env opath scope ~warn ~scope
- | _, Ok lbls ->
- let (ok, lbls) =
- match opath with
- | Some (_, _, true) ->
- (true, lbls) (* disambiguate only checks scope *)
- | _ -> disambiguate_label_by_ids (opath=None) closed ids lbls
- in
- if ok then Label.disambiguate () lid env opath (Ok lbls) ~warn ~scope
- else fst (List.hd lbls) (* will fail later *)
- in
+ let filter : Label.nonempty_candidate_filter =
+ disambiguate_label_by_ids closed ids in
+ Label.disambiguate ~warn ~filter () lid env expected_type scope in
let lbl_a_list =
List.map (fun (lid,a) -> lid, process_label lid, a) lid_a_list in
if !w_pr then
List.fold_right (fun x k ys -> f x (fun y -> k (y :: ys)))
xs (fun ys -> k (List.rev ys)) []
-let type_label_a_list ?labels loc closed env type_lbl_a opath lid_a_list k =
+let type_label_a_list
+ ?labels loc closed env type_lbl_a expected_type lid_a_list k =
let lbl_a_list =
match lid_a_list, labels with
({txt=Longident.Lident s}, _)::_, Some labels when Hashtbl.mem labels s ->
| _ -> lid_a)
lid_a_list
in
- disambiguate_lid_a_list loc closed env opath lid_a_list
+ disambiguate_lid_a_list loc closed env expected_type lid_a_list
in
(* Invariant: records are sorted in the typed tree *)
let lbl_a_list =
module Constructor = NameChoice (struct
type t = constructor_description
type usage = Env.constructor_usage
- let type_kind = "variant"
+ let kind = Datatype_kind.Variant
let get_name cstr = cstr.cstr_name
let get_type cstr = cstr.cstr_res
let lookup_all_from_type loc usage path env =
- Env.lookup_all_constructors_from_type ~loc usage path env
+ match Env.lookup_all_constructors_from_type ~loc usage path env with
+ | _ :: _ as x -> x
+ | [] ->
+ match (Env.find_type path env).type_kind with
+ | Type_open ->
+ (* Extension constructors cannot be found by looking at the type
+ declaration.
+ We scan the whole environment to get an accurate spellchecking
+ hint in the subsequent error message *)
+ let filter lbl =
+ compare_type_path env
+ path (get_constr_type_path @@ get_type lbl) in
+ let add_valid x acc = if filter x then (x,ignore)::acc else acc in
+ Env.fold_constructors add_valid None env []
+ | _ -> []
let in_env _ = true
end)
the pattern but haven't type-checked the body yet.
At this point we might have added some type equalities to the environment,
but haven't yet added identifiers bound by the pattern. *)
-type half_typed_case =
- { typed_pat: pattern;
+type 'case_pattern half_typed_case =
+ { typed_pat: 'case_pattern;
pat_type_for_unif: type_expr;
untyped_case: Parsetree.case;
branch_env: Env.t;
(** Due to GADT constraints, an or-pattern produced within
a counter-example may have ill-typed branches. Consider for example
+ {[
type _ tag = Int : int tag | Bool : bool tag
+ ]}
then [Parmatch] will propose the or-pattern [Int | Bool] whenever
a pattern of type [tag] is required to form a counter-example. For
| Refine_or of { inside_nonsplit_or: bool; }
(** Only backtrack when needed.
- [Refine_or] tries another approach for refining or-pattern.
+ [Refine_or] tries another approach for refining or-pattern.
- Instead of always splitting each or-pattern, It first attempts to
- find branches that do not introduce new constraints (because they
- do not contain GADT constructors). Those branches are such that,
- if they fail, all other branches will fail.
+ Instead of always splitting each or-pattern, It first attempts to
+ find branches that do not introduce new constraints (because they
+ do not contain GADT constructors). Those branches are such that,
+ if they fail, all other branches will fail.
- If we find one such branch, we attempt to complete the subpattern
- (checking what's outside the or-pattern), ignoring other
- branches -- we never consider another branch choice again. If all
- branches are constrained, it falls back to splitting the
- or-pattern.
+ If we find one such branch, we attempt to complete the subpattern
+ (checking what's outside the or-pattern), ignoring other
+ branches -- we never consider another branch choice again. If all
+ branches are constrained, it falls back to splitting the
+ or-pattern.
- We use this mode when checking exhaustivity of pattern matching.
- *)
+ We use this mode when checking exhaustivity of pattern matching.
+ *)
+
+(** This exception is only used internally within [type_pat_aux], in
+ counter-example mode, to jump back to the parent or-pattern in the
+ [Refine_or] strategy.
+
+ Such a parent exists precisely when [inside_nonsplit_or = true];
+ it's an invariant that we always setup an exception handler for
+ [Need_backtrack] when we set this flag. *)
+exception Need_backtrack
-(** This exception is only used internally within [type_pat_aux], to jump
- back to the parent or-pattern in the [Refine_or] strategy.
+(** This exception is only used internally within [type_pat_aux], in
+ counter-example mode. We use it to discard counter-example candidates
+ that do not match any value. *)
+exception Empty_branch
- Such a parent exists precisely when [inside_nonsplit_or = true];
- it's an invariant that we always setup an exception handler for
- [Need_backtrack] when we set this flag. *)
- exception Need_backtrack
+type abort_reason = Adds_constraints | Empty
(** Remember current typing state for backtracking.
No variable information, as we only backtrack on
let rec find_valid_alternative f pat =
match pat.ppat_desc with
| Ppat_or(p1,p2) ->
- (try find_valid_alternative f p1
- with Error _ -> find_valid_alternative f p2)
+ (try find_valid_alternative f p1 with
+ | Empty_branch | Error _ -> find_valid_alternative f p2
+ )
| _ -> f pat
let no_explosion = function
Refine_or {inside_nonsplit_or = true}
in Counter_example { info with splitting_mode }
-let rec type_pat ?(exception_allowed=false) ~no_existentials ~mode
- ~env sp expected_ty k =
+(** The typedtree has two distinct syntactic categories for patterns,
+ "value" patterns, matching on values, and "computation" patterns
+ that match on the effect of a computation -- typically, exception
+ patterns (exception p).
+
+ On the other hand, the parsetree has an unstructured representation
+ where all categories of patterns are mixed together. The
+ decomposition according to the value/computation structure has to
+ happen during type-checking.
+
+ We don't want to duplicate the type-checking logic in two different
+ functions, depending on the kind of pattern to be produced. In
+ particular, there are both value and computation or-patterns, and
+ the type-checking logic for or-patterns is horribly complex; having
+ it in two different places would be twice as horirble.
+
+ The solution is to pass a GADT tag to [type_pat] to indicate whether
+ a value or computation pattern is expected. This way, there is a single
+ place where [Ppat_or] nodes are type-checked, the checking logic is shared,
+ and only at the end do we inspect the tag to decide to produce a value
+ or computation pattern.
+*)
+let pure
+ : type k . k pattern_category -> value general_pattern -> k general_pattern
+ = fun category pat ->
+ match category with
+ | Value -> pat
+ | Computation -> as_computation_pattern pat
+
+let only_impure
+ : type k . k pattern_category ->
+ computation general_pattern -> k general_pattern
+ = fun category pat ->
+ match category with
+ | Value ->
+ (* LATER: this exception could be renamed/generalized *)
+ raise (Error (pat.pat_loc, pat.pat_env,
+ Exception_pattern_disallowed))
+ | Computation -> pat
+
+let as_comp_pattern
+ : type k . k pattern_category ->
+ k general_pattern -> computation general_pattern
+ = fun category pat ->
+ match category with
+ | Value -> as_computation_pattern pat
+ | Computation -> pat
+
+(* type_pat propagates the expected type.
+ Unification may update the typing environment.
+
+ In counter-example mode, [Empty_branch] is raised when the counter-example
+ does not match any value. *)
+let rec type_pat
+ : type k r . k pattern_category -> no_existentials:_ -> mode:_ ->
+ env:_ -> _ -> _ -> (k general_pattern -> r) -> r
+ = fun category ~no_existentials ~mode
+ ~env sp expected_ty k ->
Builtin_attributes.warning_scope sp.ppat_attributes
(fun () ->
- type_pat_aux ~exception_allowed ~no_existentials ~mode
+ type_pat_aux category ~no_existentials ~mode
~env sp expected_ty k
)
-and type_pat_aux ~exception_allowed ~no_existentials ~mode
- ~env sp expected_ty k =
- let type_pat ?(exception_allowed=false) ?(mode=mode) ?(env=env) =
- type_pat ~exception_allowed ~no_existentials ~mode ~env
+and type_pat_aux
+ : type k r . k pattern_category -> no_existentials:_ -> mode:_ ->
+ env:_ -> _ -> _ -> (k general_pattern -> r) -> r
+ = fun category ~no_existentials ~mode
+ ~env sp expected_ty k ->
+ let type_pat category ?(mode=mode) ?(env=env) =
+ type_pat category ~no_existentials ~mode ~env
in
let loc = sp.ppat_loc in
let refine = match mode with Normal -> false | Counter_example _ -> true in
- let rup k x =
- if mode = Normal then (ignore (rp x));
+ let unif (x : pattern) : pattern =
unify_pat ~refine env x (instance expected_ty);
- k x
+ x
in
- let rp k x : pattern = if mode = Normal then k (rp x) else k x in
+ let rp x =
+ let crp (x : k general_pattern) : k general_pattern =
+ match category with
+ | Value -> rp x
+ | Computation -> rcp x in
+ if mode = Normal then crp x else x in
+ let rp k x = k (rp x)
+ and rvp k x = k (rp (pure category x))
+ and rcp k x = k (rp (only_impure category x)) in
let construction_not_used_in_counterexamples = (mode = Normal) in
let must_backtrack_on_gadt = match get_splitting_mode mode with
| None -> false
in
match sp.ppat_desc with
Ppat_any ->
- let k' d = rp k {
+ let k' d = rvp k {
pat_desc = d;
pat_loc = loc; pat_extra=[];
pat_type = instance expected_ty;
| Counter_example {explosion_fuel; _} when explosion_fuel <= 0 ->
k' Tpat_any
| Counter_example ({explosion_fuel; _} as info) ->
- begin match Parmatch.ppat_of_type !env expected_ty with
- | exception Parmatch.Empty -> raise (Error (loc, !env, Empty_pattern))
- | (sp, constrs, labels) ->
- if sp.ppat_desc = Parsetree.Ppat_any then k' Tpat_any else
- if must_backtrack_on_gadt then raise Need_backtrack else
+ let open Parmatch in
+ begin match ppat_of_type !env expected_ty with
+ | PT_empty -> raise Empty_branch
+ | PT_any -> k' Tpat_any
+ | PT_pattern (explosion, sp, constrs, labels) ->
let explosion_fuel =
- match sp.ppat_desc with
- Parsetree.Ppat_or _ -> explosion_fuel - 5
- | _ -> explosion_fuel - 1
+ match explosion with
+ | PE_single -> explosion_fuel - 1
+ | PE_gadt_cases ->
+ if must_backtrack_on_gadt then raise Need_backtrack;
+ explosion_fuel - 5
in
let mode =
Counter_example { info with explosion_fuel; constrs; labels }
in
- type_pat ~mode sp expected_ty k
+ type_pat category ~mode sp expected_ty k
end
end
| Ppat_var name ->
else
enter_variable loc name ty sp.ppat_attributes
in
- rp k {
+ rvp k {
pat_desc = Tpat_var (id, name);
pat_loc = loc; pat_extra=[];
pat_type = ty;
let t = instance expected_ty in
begin match name.txt with
| None ->
- rp k {
+ rvp k {
pat_desc = Tpat_any;
pat_loc = sp.ppat_loc;
pat_extra=[Tpat_unpack, name.loc, sp.ppat_attributes];
| Some s ->
let v = { name with txt = s } in
let id = enter_variable loc v t ~is_module:true sp.ppat_attributes in
- rp k {
+ rvp k {
pat_desc = Tpat_var (id, v);
pat_loc = sp.ppat_loc;
pat_extra=[Tpat_unpack, loc, sp.ppat_attributes];
end_def ();
generalize ty';
let id = enter_variable lloc name ty' attrs in
- rp k {
+ rvp k {
pat_desc = Tpat_var (id, name);
pat_loc = lloc;
pat_extra = [Tpat_constraint cty, loc, sp.ppat_attributes];
end
| Ppat_alias(sq, name) ->
assert construction_not_used_in_counterexamples;
- type_pat sq expected_ty (fun q ->
+ type_pat Value sq expected_ty (fun q ->
begin_def ();
let ty_var = build_as_type env q in
end_def ();
let id =
enter_variable ~is_as_variable:true loc name ty_var sp.ppat_attributes
in
- rp k {
+ rvp k {
pat_desc = Tpat_alias(q, id, name);
pat_loc = loc; pat_extra=[];
pat_type = q.pat_type;
pat_env = !env })
| Ppat_constant cst ->
let cst = constant_or_raise !env loc cst in
- rup k {
+ rvp k @@ unif {
pat_desc = Tpat_constant cst;
pat_loc = loc; pat_extra=[];
pat_type = type_constant cst;
in
let p = if c1 <= c2 then loop c1 c2 else loop c2 c1 in
let p = {p with ppat_loc=loc} in
- type_pat ~mode:(no_explosion mode) p expected_ty k
+ type_pat category ~mode:(no_explosion mode) p expected_ty k
(* TODO: record 'extra' to remember about interval *)
| Ppat_interval _ ->
raise (Error (loc, !env, Invalid_interval))
end_def ();
generalize_structure expected_ty;
unify_pat_types ~refine loc env ty expected_ty;
- map_fold_cont (fun (p,t) -> type_pat p t) spl_ann (fun pl ->
- rp k {
+ map_fold_cont (fun (p,t) -> type_pat Value p t) spl_ann (fun pl ->
+ rvp k {
pat_desc = Tpat_tuple pl;
pat_loc = loc; pat_extra=[];
pat_type = newty (Ttuple(List.map (fun p -> p.pat_type) pl));
pat_attributes = sp.ppat_attributes;
pat_env = !env })
| Ppat_construct(lid, sarg) ->
- let opath =
+ let expected_type =
try
let (p0, p, _) = extract_concrete_variant !env expected_ty in
Some (p0, p, true)
Env.lookup_all_constructors Env.Pattern ~loc:lid.loc lid.txt !env in
wrap_disambiguate "This variant pattern is expected to have"
(mk_expected expected_ty)
- (Constructor.disambiguate Env.Pattern lid !env opath) candidates
+ (Constructor.disambiguate Env.Pattern lid !env expected_type)
+ candidates
in
if constr.cstr_generalized && must_backtrack_on_gadt then
raise Need_backtrack;
in
if constr.cstr_inlined <> None then List.iter check_non_escaping sargs;
- map_fold_cont (fun (p,t) -> type_pat p t) (List.combine sargs ty_args)
- (fun args ->
- rp k {
- pat_desc=Tpat_construct(lid, constr, args);
- pat_loc = loc; pat_extra=[];
- pat_type = instance expected_ty;
- pat_attributes = sp.ppat_attributes;
- pat_env = !env })
+ map_fold_cont
+ (fun (p,t) -> type_pat Value p t)
+ (List.combine sargs ty_args)
+ (fun args ->
+ rvp k {
+ pat_desc=Tpat_construct(lid, constr, args);
+ pat_loc = loc; pat_extra=[];
+ pat_type = instance expected_ty;
+ pat_attributes = sp.ppat_attributes;
+ pat_env = !env })
| Ppat_variant(l, sarg) ->
let arg_type = match sarg with None -> [] | Some _ -> [newgenvar()] in
let row = { row_fields =
then assert (match mode with Normal -> false | Counter_example _ -> true)
else unify_pat_types ~refine loc env (newgenty(Tvariant row)) expected_ty;
let k arg =
- rp k {
+ rvp k {
pat_desc = Tpat_variant(l, arg, ref {row with row_more = newvar()});
pat_loc = loc; pat_extra=[];
pat_type = instance expected_ty;
in begin
(* PR#6235: propagate type information *)
match sarg, arg_type with
- Some p, [ty] -> type_pat p ty (fun p -> k (Some p))
+ Some p, [ty] -> type_pat Value p ty (fun p -> k (Some p))
| _ -> k None
end
| Ppat_record(lid_sp_list, closed) ->
assert (lid_sp_list <> []);
- let opath, record_ty =
+ let expected_type, record_ty =
try
let (p0, p,_) = extract_concrete_record !env expected_ty in
begin_def ();
end_def ();
generalize_structure ty_res;
generalize_structure ty_arg;
- type_pat sarg ty_arg (fun arg ->
+ type_pat Value sarg ty_arg (fun arg ->
k (label_lid, label, arg))
in
- let k' k lbl_pat_list =
+ let make_record_pat lbl_pat_list =
check_recordpat_labels loc lbl_pat_list closed;
- rup k {
- pat_desc = Tpat_record (lbl_pat_list, closed);
- pat_loc = loc; pat_extra=[];
- pat_type = instance record_ty;
- pat_attributes = sp.ppat_attributes;
- pat_env = !env }
+ {
+ pat_desc = Tpat_record (lbl_pat_list, closed);
+ pat_loc = loc; pat_extra=[];
+ pat_type = instance record_ty;
+ pat_attributes = sp.ppat_attributes;
+ pat_env = !env;
+ }
in
+ let k' pat = rvp k (unif pat) in
begin match mode with
| Normal ->
- k (wrap_disambiguate "This record pattern is expected to have"
+ k' (wrap_disambiguate "This record pattern is expected to have"
(mk_expected expected_ty)
- (type_label_a_list loc false !env type_label_pat opath
+ (type_label_a_list loc false !env type_label_pat expected_type
lid_sp_list)
- (k' (fun x -> x)))
+ make_record_pat)
| Counter_example {labels; _} ->
- type_label_a_list ~labels loc false !env type_label_pat opath
- lid_sp_list (k' k)
+ type_label_a_list ~labels loc false !env type_label_pat expected_type
+ lid_sp_list (fun lbl_pat_list -> k' (make_record_pat lbl_pat_list))
end
| Ppat_array spl ->
let ty_elt = newgenvar() in
generalize_structure expected_ty;
unify_pat_types ~refine
loc env (Predef.type_array ty_elt) expected_ty;
- map_fold_cont (fun p -> type_pat p ty_elt) spl (fun pl ->
- rp k {
+ map_fold_cont (fun p -> type_pat Value p ty_elt) spl (fun pl ->
+ rvp k {
pat_desc = Tpat_array pl;
pat_loc = loc; pat_extra=[];
pat_type = instance expected_ty;
let state = save_state env in
let split_or sp =
assert may_split;
- let typ pat = type_pat ~exception_allowed pat expected_ty k in
+ let typ pat = type_pat category pat expected_ty k in
find_valid_alternative (fun pat -> set_state state env; typ pat) sp in
if must_split then split_or sp else begin
let initial_pattern_variables = !pattern_variables in
gadt_equations_level := Some lev;
let env1 = ref !env in
let inside_or = enter_nonsplit_or mode in
- let p1 =
- try Some (type_pat ~exception_allowed ~mode:inside_or
- sp1 expected_ty ~env:env1 (fun x -> x))
- with Need_backtrack -> None in
+ let type_pat_result env sp : (_, abort_reason) result =
+ match
+ type_pat category ~mode:inside_or sp expected_ty ~env (fun x -> x)
+ with
+ | res -> Ok res
+ | exception Need_backtrack -> Error Adds_constraints
+ | exception Empty_branch -> Error Empty
+ in
+ let p1 = type_pat_result env1 sp1 in
let p1_variables = !pattern_variables in
let p1_module_variables = !module_variables in
pattern_variables := initial_pattern_variables;
module_variables := initial_module_variables;
let env2 = ref !env in
- let p2 =
- try Some (type_pat ~exception_allowed ~mode:inside_or
- sp2 expected_ty ~env:env2 (fun x -> x))
- with Need_backtrack -> None in
+ let p2 = type_pat_result env2 sp2 in
end_def ();
gadt_equations_level := equation_level;
let p2_variables = !pattern_variables in
check_scope_escape pv_loc !env2 outter_lev pv_type
) p2_variables;
begin match p1, p2 with
- | None, None ->
- let inside_nonsplit_or =
- match get_splitting_mode mode with
- | None | Some Backtrack_or -> false
- | Some (Refine_or {inside_nonsplit_or}) -> inside_nonsplit_or in
- if inside_nonsplit_or
- then raise Need_backtrack
- else split_or sp
- | Some p, None | None, Some p -> rp k p (* no variables in this case *)
- | Some p1, Some p2 ->
- let alpha_env =
- enter_orpat_variables loc !env p1_variables p2_variables in
- pattern_variables := p1_variables;
- module_variables := p1_module_variables;
- rp k { pat_desc = Tpat_or(p1, alpha_pat alpha_env p2, None);
- pat_loc = loc;
- pat_extra=[];
- pat_type = instance expected_ty;
- pat_attributes = sp.ppat_attributes;
- pat_env = !env }
+ | Error Empty, Error Empty ->
+ raise Empty_branch
+ | Error Adds_constraints, Error _
+ | Error _, Error Adds_constraints ->
+ let inside_nonsplit_or =
+ match get_splitting_mode mode with
+ | None | Some Backtrack_or -> false
+ | Some (Refine_or {inside_nonsplit_or}) -> inside_nonsplit_or in
+ if inside_nonsplit_or
+ then raise Need_backtrack
+ else split_or sp
+ | Ok p, Error _
+ | Error _, Ok p ->
+ rp k p
+ | Ok p1, Ok p2 ->
+ let alpha_env =
+ enter_orpat_variables loc !env p1_variables p2_variables in
+ let p2 = alpha_pat alpha_env p2 in
+ pattern_variables := p1_variables;
+ module_variables := p1_module_variables;
+ let make_pat desc =
+ { pat_desc = desc;
+ pat_loc = loc; pat_extra=[];
+ pat_type = instance expected_ty;
+ pat_attributes = sp.ppat_attributes;
+ pat_env = !env } in
+ rp k (make_pat (Tpat_or(p1, p2, None)))
end
end
| Ppat_lazy sp1 ->
let nv = newgenvar () in
unify_pat_types ~refine loc env (Predef.type_lazy_t nv) expected_ty;
(* do not explode under lazy: PR#7421 *)
- type_pat ~mode:(no_explosion mode) sp1 nv (fun p1 ->
- rp k {
+ type_pat Value ~mode:(no_explosion mode) sp1 nv (fun p1 ->
+ rvp k {
pat_desc = Tpat_lazy p1;
pat_loc = loc; pat_extra=[];
pat_type = instance expected_ty;
generalize_structure ty;
let ty, expected_ty' = instance ty, ty in
unify_pat_types ~refine loc env ty (instance expected_ty);
- type_pat ~exception_allowed sp expected_ty' (fun p ->
+ type_pat category sp expected_ty' (fun p ->
(*Format.printf "%a@.%a@."
Printtyp.raw_type_expr ty
Printtyp.raw_type_expr p.pat_type;*)
pattern_force := force :: !pattern_force;
let extra = (Tpat_constraint cty, loc, sp.ppat_attributes) in
- let p =
- match p.pat_desc with
- Tpat_var (id,s) ->
- {p with pat_type = ty;
- pat_desc = Tpat_alias
- ({p with pat_desc = Tpat_any; pat_attributes = []}, id,s);
- pat_extra = [extra];
- }
- | _ -> {p with pat_type = ty;
- pat_extra = extra :: p.pat_extra}
+ let p : k general_pattern =
+ match category, (p : k general_pattern) with
+ | Value, {pat_desc = Tpat_var (id,s); _} ->
+ {p with
+ pat_type = ty;
+ pat_desc =
+ Tpat_alias
+ ({p with pat_desc = Tpat_any; pat_attributes = []}, id,s);
+ pat_extra = [extra];
+ }
+ | _, p ->
+ { p with pat_type = ty; pat_extra = extra::p.pat_extra }
in k p)
| Ppat_type lid ->
let (path, p,ty) = build_or_pat !env loc lid in
unify_pat_types ~refine loc env ty (instance expected_ty);
- k { p with pat_extra =
- (Tpat_type (path, lid), loc, sp.ppat_attributes) :: p.pat_extra }
+ k @@ pure category @@ { p with pat_extra =
+ (Tpat_type (path, lid), loc, sp.ppat_attributes)
+ :: p.pat_extra }
| Ppat_open (lid,p) ->
let path, new_env =
!type_open Asttypes.Fresh !env sp.ppat_loc lid in
let new_env = ref new_env in
- type_pat ~exception_allowed ~env:new_env p expected_ty ( fun p ->
+ type_pat category ~env:new_env p expected_ty ( fun p ->
env := Env.copy_local !env ~from:!new_env;
k { p with pat_extra =( Tpat_open (path,lid,!new_env),
loc, sp.ppat_attributes) :: p.pat_extra }
)
| Ppat_exception p ->
- if not exception_allowed then
- raise (Error (loc, !env, Exception_pattern_disallowed))
- else begin
- type_pat p Predef.type_exn (fun p_exn ->
- rp k {
- pat_desc = Tpat_exception p_exn;
- pat_loc = sp.ppat_loc;
- pat_extra = [];
- pat_type = expected_ty;
- pat_env = !env;
- pat_attributes = sp.ppat_attributes;
- })
- end
+ type_pat Value p Predef.type_exn (fun p_exn ->
+ rcp k {
+ pat_desc = Tpat_exception p_exn;
+ pat_loc = sp.ppat_loc;
+ pat_extra = [];
+ pat_type = expected_ty;
+ pat_env = !env;
+ pat_attributes = sp.ppat_attributes;
+ })
| Ppat_extension ext ->
raise (Error_forward (Builtin_attributes.error_of_extension ext))
-let type_pat ?exception_allowed ?no_existentials ?(mode=Normal)
+let type_pat category ?no_existentials ?(mode=Normal)
?(lev=get_current_level()) env sp expected_ty =
Misc.protect_refs [Misc.R (gadt_equations_level, Some lev)] (fun () ->
let r =
- type_pat ?exception_allowed ~no_existentials ~mode
+ type_pat category ~no_existentials ~mode
~env sp expected_ty (fun x -> x)
in
- iter_pattern (fun p -> p.pat_env <- !env) r;
- r
+ map_general_pattern { f = fun p -> { p with pat_env = !env } } r
)
(* this function is passed to Partial.parmatch
} in
try
reset_pattern None true;
- let typed_p =
- Ctype.with_passive_variants (type_pat ~lev ~mode env p) expected_ty
- in
+ let typed_p = type_pat Value ~lev ~mode env p expected_ty in
set_state state env;
(* types are invalidated but we don't need them here *)
Some typed_p
- with Error _ ->
+ with Error _ | Empty_branch ->
set_state state env;
None
Env.add_value ?check pv_id
{val_type = pv_type; val_kind = Val_reg; Types.val_loc = pv_loc;
val_attributes = pv_attributes;
+ val_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
} env
)
pv env
-let type_pattern ?exception_allowed ~lev env spat scope expected_ty =
+let type_pattern category ~lev env spat scope expected_ty =
reset_pattern scope true;
let new_env = ref env in
- let pat = type_pat ?exception_allowed ~lev new_env spat expected_ty in
+ let pat = type_pat category ~lev new_env spat expected_ty in
let pvs = get_ref pattern_variables in
let unpacks = get_ref module_variables in
(pat, !new_env, get_ref pattern_force, pvs, unpacks)
-let type_pattern_list no_existentials env spatl scope expected_tys allow =
+let type_pattern_list
+ category no_existentials env spatl scope expected_tys allow
+ =
reset_pattern scope allow;
let new_env = ref env in
let type_pat (attrs, pat) ty =
Builtin_attributes.warning_scope ~ppwarning:false attrs
(fun () ->
- type_pat ~no_existentials new_env pat ty
+ type_pat category ~no_existentials new_env pat ty
)
in
let patl = List.map2 type_pat spatl expected_tys in
let pvs = get_ref pattern_variables in
- let unpacks = get_ref module_variables in
+ let unpacks =
+ List.map (fun (name, loc) ->
+ name, loc, Uid.mk ~current_unit:(Env.get_unit_name ())
+ ) (get_ref module_variables)
+ in
let new_env = add_pattern_variables !new_env pvs in
(patl, new_env, get_ref pattern_force, pvs, unpacks)
let type_class_arg_pattern cl_num val_env met_env l spat =
reset_pattern None false;
let nv = newvar () in
- let pat = type_pat ~no_existentials:In_class_args (ref val_env) spat nv in
+ let pat =
+ type_pat Value ~no_existentials:In_class_args (ref val_env) spat nv in
if has_variants pat then begin
Parmatch.pressure_variants val_env [pat];
- iter_pattern finalize_variant pat
+ finalize_variants pat;
end;
List.iter (fun f -> f()) (get_ref pattern_force);
if is_optional l then unify_pat (ref val_env) pat (type_option (newvar ()));
- let (pv, met_env) =
+ let (pv, val_env, met_env) =
List.fold_right
- (fun {pv_id; pv_type; pv_loc; pv_as_var; pv_attributes} (pv, env) ->
+ (fun {pv_id; pv_type; pv_loc; pv_as_var; pv_attributes}
+ (pv, val_env, met_env) ->
let check s =
if pv_as_var then Warnings.Unused_var s
else Warnings.Unused_var_strict s in
- let id' = Ident.create_local (Ident.name pv_id) in
- ((id', pv_id, pv_type)::pv,
- Env.add_value id' {val_type = pv_type;
- val_kind = Val_ivar (Immutable, cl_num);
- val_attributes = pv_attributes;
- Types.val_loc = pv_loc;
- } ~check
- env))
- !pattern_variables ([], met_env)
+ let id' = Ident.rename pv_id in
+ let val_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) in
+ let val_env =
+ Env.add_value pv_id
+ { val_type = pv_type
+ ; val_kind = Val_reg
+ ; val_attributes = pv_attributes
+ ; val_loc = pv_loc
+ ; val_uid
+ }
+ val_env
+ in
+ let met_env =
+ Env.add_value id' ~check
+ { val_type = pv_type
+ ; val_kind = Val_ivar (Immutable, cl_num)
+ ; val_attributes = pv_attributes
+ ; val_loc = pv_loc
+ ; val_uid
+ }
+ met_env
+ in
+ ((id', pv_id, pv_type)::pv, val_env, met_env))
+ !pattern_variables ([], val_env, met_env)
in
- let val_env = add_pattern_variables val_env (get_ref pattern_variables) in
(pat, pv, val_env, met_env)
let type_self_pattern cl_num privty val_env met_env par_env spat =
in
reset_pattern None false;
let nv = newvar() in
- let pat = type_pat ~no_existentials:In_self_pattern (ref val_env) spat nv in
+ let pat =
+ type_pat Value ~no_existentials:In_self_pattern (ref val_env) spat nv in
List.iter (fun f -> f()) (get_ref pattern_force);
let meths = ref Meths.empty in
let vars = ref Vars.empty in
(val_env, met_env, par_env) ->
let name = Ident.name pv_id in
(Env.enter_unbound_value name Val_unbound_self val_env,
- Env.add_value pv_id {val_type = pv_type;
- val_kind =
- Val_self (meths, vars, cl_num, privty);
- val_attributes = pv_attributes;
- Types.val_loc = pv_loc;
- }
+ Env.add_value pv_id
+ {val_type = pv_type;
+ val_kind = Val_self (meths, vars, cl_num, privty);
+ val_attributes = pv_attributes;
+ val_loc = pv_loc;
+ val_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
+ }
~check:(fun s -> if pv_as_var then Warnings.Unused_var s
else Warnings.Unused_var_strict s)
met_env,
(* Not sure this is necessary, if [e] is nonexpansive then we shouldn't
care if there are exception patterns. But the previous version enforced
that there be none, so... *)
- let contains_exception_pat p =
- let res = ref false in
- iter_pattern (fun p ->
+ let contains_exception_pat pat =
+ exists_general_pattern { f = fun (type k) (p : k general_pattern) ->
match p.pat_desc with
- | Tpat_exception _ -> res := true
- | _ -> ()
- ) p;
- !res
+ | Tpat_exception _ -> true
+ | _ -> false } pat
in
is_nonexpansive e &&
List.for_all
raise(Error(expr.cl_loc, env, Illegal_class_expr)))
exprs
+let is_prim ~name funct =
+ match funct.exp_desc with
+ | Texp_ident (_, _, {val_kind=Val_prim{Primitive.prim_name; _}}) ->
+ prim_name = name
+ | _ -> false
(* Approximate the type of an expression, for better recursion *)
let rec approx_type env sty =
let list_labels env ty =
wrap_trace_gadt_instances env (list_labels_aux env [] []) ty
-(* Check that all univars are safe in a type *)
-let check_univars env expans kind exp ty_expected vars =
- if expans && maybe_expansive exp then
- lower_contravariant env exp.exp_type;
- (* need to expand twice? cf. Ctype.unify2 *)
- let vars = List.map (expand_head env) vars in
- let vars = List.map (expand_head env) vars in
- let vars' =
- List.filter
- (fun t ->
- let t = repr t in
- generalize t;
- match t.desc with
- Tvar name when t.level = generic_level ->
- set_type_desc t (Tunivar name); true
- | _ -> false)
- vars in
- if List.length vars = List.length vars' then () else
- let ty = newgenty (Tpoly(repr exp.exp_type, vars'))
- and ty_expected = repr ty_expected in
- raise (Error (exp.exp_loc, env,
- Less_general(kind, [Unification_trace.diff ty ty_expected])))
+(* Check that all univars are safe in a type. Both exp.exp_type and
+ ty_expected should already be generalized. *)
+let check_univars env kind exp ty_expected vars =
+ let pty = instance ty_expected in
+ begin_def ();
+ let exp_ty, vars =
+ match pty.desc with
+ Tpoly (body, tl) ->
+ (* Enforce scoping for type_let:
+ since body is not generic, instance_poly only makes
+ copies of nodes that have a Tvar as descendant *)
+ let _, ty' = instance_poly true tl body in
+ let vars, exp_ty = instance_parameterized_type vars exp.exp_type in
+ unify_exp_types exp.exp_loc env exp_ty ty';
+ exp_ty, vars
+ | _ -> assert false
+ in
+ end_def ();
+ generalize exp_ty;
+ List.iter generalize vars;
+ let ty, complete = polyfy env exp_ty vars in
+ if not complete then
+ let ty_expected = instance ty_expected in
+ raise (Error (exp.exp_loc, env,
+ Less_general(kind, [Unification_trace.diff ty ty_expected])))
+
+let generalize_and_check_univars env kind exp ty_expected vars =
+ generalize exp.exp_type;
+ generalize ty_expected;
+ List.iter generalize vars;
+ check_univars env kind exp ty_expected vars
let check_partial_application statement exp =
let rec f delay =
in
(s, fields, ty)
- let wrap_unpacks sexp unpacks =
- let open Ast_helper in
- List.fold_left
- (fun sexp (name, loc) ->
- Exp.letmodule ~loc:{ sexp.pexp_loc with loc_ghost = true }
- ~attrs:[Attr.mk (mknoloc "#modulepat") (PStr [])]
- { name with txt = Some name.txt }
- (Mod.unpack ~loc
- (Exp.ident ~loc:name.loc (mkloc (Longident.Lident name.txt)
- name.loc)))
- sexp
- )
- sexp unpacks
-
(* Helpers for type_cases *)
let contains_variant_either ty =
| _ -> false)
p
-let contains_gadt cp =
- exists_pattern
- (function
- | {pat_desc = Tpat_construct (_, cd, _)} when cd.cstr_generalized -> true
- | _ -> false)
- cp
+let contains_gadt p =
+ exists_general_pattern { f = fun (type k) (p : k general_pattern) ->
+ match p.pat_desc with
+ | Tpat_construct (_, cd, _) when cd.cstr_generalized -> true
+ | _ -> false } p
(* There are various things that we need to do in presence of GADT constructors
that aren't required if there are none.
p
let check_absent_variant env =
- iter_pattern
- (function {pat_desc = Tpat_variant (s, arg, row)} as pat ->
+ iter_general_pattern { f = fun (type k) (pat : k general_pattern) ->
+ match pat.pat_desc with
+ | Tpat_variant (s, arg, row) ->
let row = row_repr !row in
if List.exists (fun (s',fi) -> s = s' && row_field_repr fi <> Rabsent)
row.row_fields
(* Should fail *)
unify_pat (ref env) {pat with pat_type = newty (Tvariant row')}
(correct_levels pat.pat_type)
- | _ -> ())
+ | _ -> () }
(* Getting proper location of already typed expressions.
exp_type = instance desc.val_type;
exp_attributes = sexp.pexp_attributes;
exp_env = env }
- | Pexp_constant(Pconst_string (str, _) as cst) -> (
+ | Pexp_constant(Pconst_string (str, _, _) as cst) -> (
let cst = constant_or_raise env loc cst in
(* Terrible hack for format strings *)
let ty_exp = expand_head env ty_expected in
in
let (pat_exp_list, new_env, unpacks) =
type_let existential_context env rec_flag spat_sexp_list scp true in
- let body =
- type_expect new_env (wrap_unpacks sbody unpacks)
- ty_expected_explained in
+ let body = type_unpacks new_env unpacks sbody ty_expected_explained in
let () =
if rec_flag = Recursive then
check_recursive_bindings env pat_exp_list
if maybe_expansive arg then lower_contravariant env arg.exp_type;
generalize arg.exp_type;
let cases, partial =
- type_cases ~exception_allowed:true env arg.exp_type ty_expected true loc
- caselist
- in
+ type_cases Computation env arg.exp_type ty_expected true loc caselist in
re {
exp_desc = Texp_match(arg, cases, partial);
exp_loc = loc; exp_extra = [];
| Pexp_try(sbody, caselist) ->
let body = type_expect env sbody ty_expected_explained in
let cases, _ =
- type_cases env Predef.type_exn ty_expected false loc caselist in
+ type_cases Value env Predef.type_exn ty_expected false loc caselist in
re {
exp_desc = Texp_try(body, cases);
exp_loc = loc; exp_extra = [];
end;
Some exp
in
- let ty_record, opath =
+ let ty_record, expected_type =
let get_path ty =
try
let (p0, p,_) = extract_concrete_record env ty in
(mk_expected ty_record)
(type_label_a_list loc closed env
(fun e k -> k (type_label_exp true env loc ty_record e))
- opath lid_sexp_list)
+ expected_type lid_sexp_list)
(fun x -> x)
in
with_explanation (fun () ->
let num_fields =
match lbl_exp_list with [] -> assert false
| (_, lbl,_)::_ -> Array.length lbl.lbl_all in
- let opt_exp =
- if opt_sexp <> None && List.length lid_sexp_list = num_fields then
- (Location.prerr_warning loc Warnings.Useless_record_with; None)
- else opt_exp
- in
+ if opt_sexp <> None && List.length lid_sexp_list = num_fields then
+ Location.prerr_warning loc Warnings.Useless_record_with;
let label_descriptions, representation =
let (_, { lbl_all; lbl_repres }, _) = List.hd lbl_exp_list in
lbl_all, lbl_repres
exp_attributes = sexp.pexp_attributes;
exp_env = env }
| Pexp_setfield(srecord, lid, snewval) ->
- let (record, label, opath) = type_label_access env srecord lid in
- let ty_record = if opath = None then newvar () else record.exp_type in
+ let (record, label, expected_type) =
+ type_label_access env srecord lid in
+ let ty_record =
+ if expected_type = None then newvar () else record.exp_type in
let (label_loc, label, newval) =
type_label_exp false env loc ty_record (lid, label, snewval) in
unify_exp env record ty_record;
match param.ppat_desc with
| Ppat_any -> Ident.create_local "_for", env
| Ppat_var {txt} ->
- Env.enter_value txt {val_type = instance Predef.type_int;
- val_attributes = [];
- val_kind = Val_reg; Types.val_loc = loc; } env
+ Env.enter_value txt
+ {val_type = instance Predef.type_int;
+ val_attributes = [];
+ val_kind = Val_reg;
+ val_loc = loc;
+ val_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
+ } env
~check:(fun s -> Warnings.Unused_for_index s)
| _ ->
raise (Error (param.ppat_loc, env, Invalid_for_loop_index))
{val_type = method_type;
val_kind = Val_reg;
val_attributes = [];
- Types.val_loc = Location.none}
+ val_loc = Location.none;
+ val_uid = Uid.internal_not_actually_unique;
+ }
in
let exp_env = Env.add_value method_id method_desc env in
let exp =
in
let scope = create_scope () in
let md =
- { md_type = modl.mod_type; md_attributes = []; md_loc = name.loc }
+ { md_type = modl.mod_type; md_attributes = []; md_loc = name.loc;
+ md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); }
in
let (id, new_env) =
match name.txt with
end;
let exp = type_expect env sbody (mk_expected ty'') in
end_def ();
- check_univars env false "method" exp ty_expected vars;
+ generalize_and_check_univars env "method" exp ty_expected vars;
{ exp with exp_type = instance ty }
| Tvar _ ->
let exp = type_exp env sbody in
type_private = Public;
type_manifest = None;
type_variance = [];
+ type_separability = [];
type_is_newtype = true;
type_expansion_scope = Btype.lowest_level;
type_loc = loc;
type_attributes = [];
type_immediate = Unknown;
type_unboxed = unboxed_false_default_false;
+ type_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
}
in
let scope = create_scope () in
let exp, ands = type_andops env slet.pbop_exp sands ty_andops in
let scase = Ast_helper.Exp.case spat_params sbody in
let cases, partial =
- type_cases env ty_params ty_func_result true loc [scase]
+ type_cases Value env ty_params ty_func_result true loc [scase]
in
let body =
match cases with
and type_ident env ?(recarg=Rejected) lid =
let (path, desc) = Env.lookup_value ~loc:lid.loc lid.txt env in
- if !Clflags.annotations then begin
- let dloc = desc.Types.val_loc in
- let annot =
- if dloc.Location.loc_ghost then Annot.Iref_external
- else Annot.Iref_internal dloc
- in
- let name = Path.name ~paren:Oprint.parenthesized_ident path in
- Stypes.record (Stypes.An_ident (lid.loc, name, annot))
- end;
let is_recarg =
match (repr desc.val_type).desc with
| Tconstr(p, _, _) -> Path.is_constructor_typath p
generalize_structure ty_res
end;
let cases, partial =
- type_cases ~in_function:(loc_fun,ty_fun) env ty_arg ty_res
+ type_cases Value ~in_function:(loc_fun,ty_fun) env ty_arg ty_res
true loc caselist in
let not_function ty =
let ls, tvar = list_labels env ty in
generalize_structure record.exp_type
end;
let ty_exp = record.exp_type in
- let opath =
+ let expected_type =
try
let (p0, p,_) = extract_concrete_record env ty_exp in
Some(p0, p, (repr ty_exp).level = generic_level || not !Clflags.principal)
let labels = Env.lookup_all_labels ~loc:lid.loc lid.txt env in
let label =
wrap_disambiguate "This expression has" (mk_expected ty_exp)
- (Label.disambiguate () lid env opath) labels in
- (record, label, opath)
+ (Label.disambiguate () lid env expected_type) labels in
+ (record, label, expected_type)
(* Typing format strings for printing or reading.
These formats are used by functions in modules Printf, Format, and Scanf.
mk_exp_loc (Pexp_construct (mk_lid_loc lid, arg)) in
let mk_cst cst = mk_exp_loc (Pexp_constant cst) in
let mk_int n = mk_cst (Pconst_integer (Int.to_string n, None))
- and mk_string str = mk_cst (Pconst_string (str, None))
+ and mk_string str = mk_cst (Pconst_string (str, loc, None))
and mk_char chr = mk_cst (Pconst_char chr) in
let rec mk_formatting_lit fmting = match fmting with
| Close_box ->
let arg = type_argument env sarg ty_arg (instance ty_arg) in
end_def ();
try
- check_univars env (vars <> []) "field value" arg label.lbl_arg vars;
- arg
+ if (vars = []) then arg
+ else begin
+ if maybe_expansive arg then
+ lower_contravariant env arg.exp_type;
+ generalize_and_check_univars env "field value" arg label.lbl_arg vars;
+ {arg with exp_type = instance arg.exp_type}
+ end
with exn when maybe_expansive arg -> try
(* Try to retype without propagating ty_arg, cf PR#4862 *)
Option.iter Btype.backtrack snap;
let arg = type_exp env sarg in
end_def ();
lower_contravariant env arg.exp_type;
- unify_exp env arg ty_arg;
- check_univars env false "field value" arg label.lbl_arg vars;
- arg
+ begin_def ();
+ let arg = {arg with exp_type = instance arg.exp_type} in
+ unify_exp env arg (instance ty_arg);
+ end_def ();
+ generalize_and_check_univars env "field value" arg label.lbl_arg vars;
+ {arg with exp_type = instance arg.exp_type}
with Error (_, _, Less_general _) as e -> raise e
| _ -> raise exn (* In case of failure return the first error *)
in
- (lid, label, {arg with exp_type = instance arg.exp_type})
+ (lid, label, arg)
and type_argument ?explanation ?recarg env sarg ty_expected' ty_expected =
(* ty_expected' may be generic *)
let desc =
{ val_type = ty; val_kind = Val_reg;
val_attributes = [];
- Types.val_loc = Location.none}
+ val_loc = Location.none;
+ val_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
+ }
in
let exp_env = Env.add_value id desc env in
{pat_desc = Tpat_var (id, mknoloc name); pat_type = ty;pat_extra=[];
let ls, tvar = list_labels env ty_fun in
tvar || List.mem l ls
in
- let ignored = ref [] in
- let rec type_unknown_args
- (args :
- (Asttypes.arg_label * (unit -> Typedtree.expression) option) list)
- omitted ty_fun = function
- [] ->
- (List.map
- (function l, None -> l, None
- | l, Some f -> l, Some (f ()))
- (List.rev args),
- instance (result_type omitted ty_fun))
- | (l1, sarg1) :: sargl ->
- let (ty1, ty2) =
- let ty_fun = expand_head env ty_fun in
- match ty_fun.desc with
- Tvar _ ->
- let t1 = newvar () and t2 = newvar () in
- let not_identity = function
- Texp_ident(_,_,{val_kind=Val_prim
- {Primitive.prim_name="%identity"}}) ->
- false
- | _ -> true
- in
- if ty_fun.level >= t1.level && not_identity funct.exp_desc then
- Location.prerr_warning sarg1.pexp_loc Warnings.Unused_argument;
- unify env ty_fun (newty (Tarrow(l1,t1,t2,Clink(ref Cunknown))));
- (t1, t2)
- | Tarrow (l,t1,t2,_) when l = l1
- || !Clflags.classic && l1 = Nolabel && not (is_optional l) ->
- (t1, t2)
- | td ->
- let ty_fun =
- match td with Tarrow _ -> newty td | _ -> ty_fun in
- let ty_res = result_type (omitted @ !ignored) ty_fun in
- match ty_res.desc with
- Tarrow _ ->
- if (!Clflags.classic || not (has_label l1 ty_fun)) then
- raise (Error(sarg1.pexp_loc, env,
- Apply_wrong_label(l1, ty_res)))
- else
- raise (Error(funct.exp_loc, env, Incoherent_label_order))
- | _ ->
- raise(Error(funct.exp_loc, env, Apply_non_function
- (expand_head env funct.exp_type)))
- in
- let optional = is_optional l1 in
- let arg1 () =
- let arg1 = type_expect env sarg1 (mk_expected ty1) in
- if optional then
- unify_exp env arg1 (type_option(newvar()));
- arg1
- in
- type_unknown_args ((l1, Some arg1) :: args) omitted ty2 sargl
+ let eliminated_optional_arguments = ref [] in
+ let omitted_parameters = ref [] in
+ let type_unknown_arg (ty_fun, typed_args) (lbl, sarg) =
+ let (ty_arg, ty_res) =
+ let ty_fun = expand_head env ty_fun in
+ match ty_fun.desc with
+ | Tvar _ ->
+ let t1 = newvar () and t2 = newvar () in
+ if ty_fun.level >= t1.level &&
+ not (is_prim ~name:"%identity" funct)
+ then
+ Location.prerr_warning sarg.pexp_loc Warnings.Unused_argument;
+ unify env ty_fun (newty (Tarrow(lbl,t1,t2,Clink(ref Cunknown))));
+ (t1, t2)
+ | Tarrow (l,t1,t2,_) when l = lbl
+ || !Clflags.classic && lbl = Nolabel && not (is_optional l) ->
+ (t1, t2)
+ | td ->
+ let ty_fun = match td with Tarrow _ -> newty td | _ -> ty_fun in
+ let ty_res =
+ result_type (!omitted_parameters @ !eliminated_optional_arguments)
+ ty_fun
+ in
+ match ty_res.desc with
+ | Tarrow _ ->
+ if !Clflags.classic || not (has_label lbl ty_fun) then
+ raise (Error(sarg.pexp_loc, env,
+ Apply_wrong_label(lbl, ty_res, false)))
+ else
+ raise (Error(funct.exp_loc, env, Incoherent_label_order))
+ | _ ->
+ raise(Error(funct.exp_loc, env, Apply_non_function
+ (expand_head env funct.exp_type)))
+ in
+ let arg () =
+ let arg = type_expect env sarg (mk_expected ty_arg) in
+ if is_optional lbl then
+ unify_exp env arg (type_option(newvar()));
+ arg
+ in
+ (ty_res, (lbl, Some arg) :: typed_args)
in
let ignore_labels =
!Clflags.classic ||
end
in
let warned = ref false in
- let rec type_args args omitted ty_fun ty_fun0 ty_old sargs more_sargs =
+ let rec type_args args ty_fun ty_fun0 sargs =
match expand_head env ty_fun, expand_head env ty_fun0 with
- {desc=Tarrow (l, ty, ty_fun, com); level=lv} as ty_fun',
+ | {desc=Tarrow (l, ty, ty_fun, com); level=lv} as ty_fun',
{desc=Tarrow (_, ty0, ty_fun0, _)}
- when (sargs <> [] || more_sargs <> []) && commu_repr com = Cok ->
+ when sargs <> [] && commu_repr com = Cok ->
let may_warn loc w =
if not !warned && !Clflags.principal && lv <> generic_level
then begin
in
let name = label_name l
and optional = is_optional l in
- let sargs, more_sargs, arg =
- if ignore_labels && not (is_optional l) then begin
- (* In classic mode, omitted = [] *)
- match sargs, more_sargs with
- (l', sarg0) :: _, _ ->
- raise(Error(sarg0.pexp_loc, env,
- Apply_wrong_label(l', ty_old)))
- | _, (l', sarg0) :: more_sargs ->
- if l <> l' && l' <> Nolabel then
- raise(Error(sarg0.pexp_loc, env,
- Apply_wrong_label(l', ty_fun')))
- else
- ([], more_sargs,
- Some (fun () -> type_argument env sarg0 ty ty0))
- | _ ->
- assert false
- end else try
- let (l', sarg0, sargs, more_sargs) =
- try
- let (l', sarg0, sargs1, sargs2) = extract_label name sargs in
- if sargs1 <> [] then
- may_warn sarg0.pexp_loc
- (Warnings.Not_principal "commuting this argument");
- (l', sarg0, sargs1 @ sargs2, more_sargs)
- with Not_found ->
- let (l', sarg0, sargs1, sargs2) =
- extract_label name more_sargs in
- if sargs1 <> [] || sargs <> [] then
- may_warn sarg0.pexp_loc
- (Warnings.Not_principal "commuting this argument");
- (l', sarg0, sargs @ sargs1, sargs2)
- in
- if not optional && is_optional l' then
- Location.prerr_warning sarg0.pexp_loc
- (Warnings.Nonoptional_label (Printtyp.string_of_label l));
- sargs, more_sargs,
+ let use_arg sarg l' =
+ Some (
if not optional || is_optional l' then
- Some (fun () -> type_argument env sarg0 ty ty0)
+ (fun () -> type_argument env sarg ty ty0)
else begin
- may_warn sarg0.pexp_loc
+ may_warn sarg.pexp_loc
(Warnings.Not_principal "using an optional argument here");
- Some (fun () -> option_some env (type_argument env sarg0
- (extract_option_type env ty)
- (extract_option_type env ty0)))
- end
- with Not_found ->
- sargs, more_sargs,
- if optional &&
- (List.mem_assoc Nolabel sargs
- || List.mem_assoc Nolabel more_sargs)
- then begin
- may_warn funct.exp_loc
- (Warnings.Without_principality "eliminated optional argument");
- ignored := (l,ty,lv) :: !ignored;
- Some (fun () -> option_none env (instance ty) Location.none)
- end else begin
- may_warn funct.exp_loc
- (Warnings.Without_principality "commuted an argument");
- None
+ (fun () -> option_some env (type_argument env sarg
+ (extract_option_type env ty)
+ (extract_option_type env ty0)))
end
+ )
+ in
+ let eliminate_optional_arg () =
+ may_warn funct.exp_loc
+ (Warnings.Without_principality "eliminated optional argument");
+ eliminated_optional_arguments :=
+ (l,ty,lv) :: !eliminated_optional_arguments;
+ Some (fun () -> option_none env (instance ty) Location.none)
+ in
+ let remaining_sargs, arg =
+ if ignore_labels then begin
+ (* No reordering is allowed, process arguments in order *)
+ match sargs with
+ | [] -> assert false
+ | (l', sarg) :: remaining_sargs ->
+ if name = label_name l' || (not optional && l' = Nolabel) then
+ (remaining_sargs, use_arg sarg l')
+ else if
+ optional &&
+ not (List.exists (fun (l, _) -> name = label_name l)
+ remaining_sargs) &&
+ List.exists (function (Nolabel, _) -> true | _ -> false)
+ sargs
+ then
+ (sargs, eliminate_optional_arg ())
+ else
+ raise(Error(sarg.pexp_loc, env,
+ Apply_wrong_label(l', ty_fun', optional)))
+ end else
+ (* Arguments can be commuted, try to fetch the argument
+ corresponding to the first parameter. *)
+ match extract_label name sargs with
+ | Some (l', sarg, commuted, remaining_sargs) ->
+ if commuted then begin
+ may_warn sarg.pexp_loc
+ (Warnings.Not_principal "commuting this argument")
+ end;
+ if not optional && is_optional l' then
+ Location.prerr_warning sarg.pexp_loc
+ (Warnings.Nonoptional_label (Printtyp.string_of_label l));
+ remaining_sargs, use_arg sarg l'
+ | None ->
+ sargs,
+ if optional && List.mem_assoc Nolabel sargs then
+ eliminate_optional_arg ()
+ else begin
+ (* No argument was given for this parameter, we abstract over
+ it. *)
+ may_warn funct.exp_loc
+ (Warnings.Without_principality "commuted an argument");
+ omitted_parameters := (l,ty,lv) :: !omitted_parameters;
+ None
+ end
in
- let omitted =
- if arg = None then (l,ty,lv) :: omitted else omitted in
- let ty_old = if sargs = [] then ty_fun else ty_old in
- type_args ((l,arg)::args) omitted ty_fun ty_fun0
- ty_old sargs more_sargs
+ type_args ((l,arg)::args) ty_fun ty_fun0 remaining_sargs
| _ ->
- match sargs with
- (l, sarg0) :: _ when ignore_labels ->
- raise(Error(sarg0.pexp_loc, env,
- Apply_wrong_label(l, ty_old)))
- | _ ->
- type_unknown_args args omitted ty_fun0
- (sargs @ more_sargs)
+ (* We're not looking at a *known* function type anymore, or there are no
+ arguments left. *)
+ let ty_fun, typed_args =
+ List.fold_left type_unknown_arg (ty_fun0, args) sargs
+ in
+ let args =
+ (* Force typing of arguments.
+ Careful: the order matters here. Using [List.rev_map] would be
+ incorrect. *)
+ List.map
+ (function
+ | l, None -> l, None
+ | l, Some f -> l, Some (f ()))
+ (List.rev typed_args)
+ in
+ let result_ty = instance (result_type !omitted_parameters ty_fun) in
+ args, result_ty
in
let is_ignore funct =
- match funct.exp_desc with
- Texp_ident (_, _, {val_kind=Val_prim{Primitive.prim_name="%ignore"}}) ->
- (try ignore (filter_arrow env (instance funct.exp_type) Nolabel);
- true
- with Unify _ -> false)
- | _ -> false
+ is_prim ~name:"%ignore" funct &&
+ (try ignore (filter_arrow env (instance funct.exp_type) Nolabel); true
+ with Unify _ -> false)
in
match sargs with
- (* Special case for ignore: avoid discarding warning *)
+ | (* Special case for ignore: avoid discarding warning *)
[Nolabel, sarg] when is_ignore funct ->
- let ty_arg, ty_res =
- filter_arrow env (instance funct.exp_type) Nolabel
- in
+ let ty_arg, ty_res = filter_arrow env (instance funct.exp_type) Nolabel in
let exp = type_expect env sarg (mk_expected ty_arg) in
check_partial_application false exp;
([Nolabel, Some exp], ty_res)
| _ ->
let ty = funct.exp_type in
- if ignore_labels then
- type_args [] [] ty (instance ty) ty [] sargs
- else
- type_args [] [] ty (instance ty) ty sargs []
+ type_args [] ty (instance ty) sargs
and type_construct env loc lid sarg ty_expected_explained attrs =
let { ty = ty_expected; explanation } = ty_expected_explained in
- let opath =
+ let expected_type =
try
let (p0, p,_) = extract_concrete_variant env ty_expected in
let principal =
let constr =
wrap_disambiguate "This variant expression is expected to have"
ty_expected_explained
- (Constructor.disambiguate Env.Positive lid env opath) constrs
+ (Constructor.disambiguate Env.Positive lid env expected_type) constrs
in
let sargs =
match sarg with
exp
end
+and type_unpacks ?in_function env unpacks sbody expected_ty =
+ let ty = newvar() in
+ (* remember original level *)
+ let extended_env, tunpacks =
+ List.fold_left (fun (env, unpacks) (name, loc, uid) ->
+ begin_def ();
+ let context = Typetexp.narrow () in
+ let modl =
+ !type_module env
+ Ast_helper.(
+ Mod.unpack ~loc
+ (Exp.ident ~loc:name.loc (mkloc (Longident.Lident name.txt)
+ name.loc)))
+ in
+ Mtype.lower_nongen ty.level modl.mod_type;
+ let pres =
+ match modl.mod_type with
+ | Mty_alias _ -> Mp_absent
+ | _ -> Mp_present
+ in
+ let scope = create_scope () in
+ let md =
+ { md_type = modl.mod_type; md_attributes = []; md_loc = name.loc;
+ md_uid = uid; }
+ in
+ let (id, env) =
+ Env.enter_module_declaration ~scope name.txt pres md env
+ in
+ Typetexp.widen context;
+ env, (id, name, pres, modl) :: unpacks
+ ) (env, []) unpacks
+ in
+ (* ideally, we should catch Expr_type_clash errors
+ in type_expect triggered by escaping identifiers from the local module
+ and refine them into Scoping_let_module errors
+ *)
+ let body = type_expect ?in_function extended_env sbody expected_ty in
+ let exp_loc = { body.exp_loc with loc_ghost = true } in
+ let exp_attributes = [Ast_helper.Attr.mk (mknoloc "#modulepat") (PStr [])] in
+ List.fold_left (fun body (id, name, pres, modl) ->
+ (* go back to parent level *)
+ end_def ();
+ Ctype.unify_var extended_env ty body.exp_type;
+ re {
+ exp_desc = Texp_letmodule(Some id, { name with txt = Some name.txt },
+ pres, modl, body);
+ exp_loc;
+ exp_attributes;
+ exp_extra = [];
+ exp_type = ty;
+ exp_env = env }
+ ) body tunpacks
+
(* Typing of match cases *)
-and type_cases ?exception_allowed ?in_function env ty_arg ty_res partial_flag
- loc caselist =
+and type_cases
+ : type k . k pattern_category ->
+ ?in_function:_ -> _ -> _ -> _ -> _ -> _ -> Parsetree.case list ->
+ k case list * partial
+ = fun category ?in_function env ty_arg ty_res partial_flag loc caselist ->
(* ty_arg is _fully_ generalized *)
let patterns = List.map (fun {pc_lhs=p} -> p) caselist in
let contains_polyvars = List.exists contains_polymorphic_variant patterns in
end_def ();
generalize_structure ty_arg;
let (pat, ext_env, force, pvs, unpacks) =
- type_pattern ?exception_allowed ~lev env pc_lhs scope ty_arg
+ type_pattern category ~lev env pc_lhs scope ty_arg
in
pattern_force := force @ !pattern_force;
let pat =
branch_env = ext_env;
pat_vars = pvs;
unpacks;
- contains_gadt = contains_gadt pat; }
+ contains_gadt = contains_gadt (as_comp_pattern category pat); }
)
caselist in
let patl = List.map (fun { typed_pat; _ } -> typed_pat) half_typed_cases in
unify_pats ty_arg';
(* Check for polymorphic variants to close *)
if List.exists has_variants patl then begin
- Parmatch.pressure_variants env patl;
- List.iter (iter_pattern finalize_variant) patl
+ Parmatch.pressure_variants_in_computation_pattern env
+ (List.map (as_comp_pattern category) patl);
+ List.iter finalize_variants patl
end;
(* `Contaminating' unifications start here *)
List.iter (fun f -> f()) !pattern_force;
~check:(fun s -> Warnings.Unused_var_strict s)
~check_as:(fun s -> Warnings.Unused_var s)
in
- let sexp = wrap_unpacks pc_rhs unpacks in
+ let unpacks =
+ List.map (fun (name, loc) ->
+ name, loc, Uid.mk ~current_unit:(Env.get_unit_name ())
+ ) unpacks
+ in
let ty_res' =
if !Clflags.principal then begin
begin_def ();
| None -> None
| Some scond ->
Some
- (type_expect ext_env (wrap_unpacks scond unpacks)
+ (type_unpacks ext_env unpacks scond
(mk_expected ~explanation:When_guard Predef.type_bool))
in
let exp =
- type_expect ?in_function ext_env sexp (mk_expected ty_res') in
+ type_unpacks ?in_function ext_env unpacks pc_rhs (mk_expected ty_res')
+ in
{
c_lhs = pat;
c_guard = guard;
Subst.type_expr (Subst.for_saving Subst.identity) ty_arg'
else ty_arg'
in
- let val_cases, exn_cases = split_cases env cases in
+ let val_cases, exn_cases =
+ match category with
+ | Value -> (cases : value case list), []
+ | Computation -> split_cases env cases in
if val_cases = [] && exn_cases <> [] then
raise (Error (loc, env, No_value_clauses));
let partial =
in
let unused_check delayed =
List.iter (fun { typed_pat; branch_env; _ } ->
- check_absent_variant branch_env typed_pat
+ check_absent_variant branch_env (as_comp_pattern category typed_pat)
) half_typed_cases;
if delayed then (begin_def (); init_def lev);
check_unused ~lev env ty_arg_check val_cases ;
spat_sexp_list in
let nvs = List.map (fun _ -> newvar ()) spatl in
let (pat_list, new_env, force, pvs, unpacks) =
- type_pattern_list existential_context env spatl scope nvs allow in
+ type_pattern_list Value existential_context env spatl scope nvs allow in
let attrs_list = List.map fst spatl in
let is_recursive = (rec_flag = Recursive) in
(* If recursive, first unify with an approximation of the expression *)
(fun pat ->
if has_variants pat then begin
Parmatch.pressure_variants env [pat];
- iter_pattern finalize_variant pat
+ finalize_variants pat
end)
pat_list;
(* Generalize the structure *)
((if !some_used then check_strict else check) name)
);
Env.set_value_used_callback
- name vd
+ vd
(fun () ->
match !current_slot with
| Some slot ->
- slot := (name, vd) :: !slot; rec_needed := true
+ slot := vd.val_uid :: !slot; rec_needed := true
| None ->
- List.iter
- (fun (name, vd) -> Env.mark_value_used name vd)
- (get_ref slot);
+ List.iter Env.mark_value_used (get_ref slot);
used := true;
some_used := true
)
let exp_list =
List.map2
(fun {pvb_expr=sexp; pvb_attributes; _} (pat, slot) ->
- let sexp =
- if rec_flag = Recursive then wrap_unpacks sexp unpacks else sexp in
if is_recursive then current_slot := slot;
match pat.pat_type.desc with
| Tpoly (ty, tl) ->
- begin_def ();
if !Clflags.principal then begin_def ();
let vars, ty' = instance_poly ~keep_names:true true tl ty in
if !Clflags.principal then begin
generalize_structure ty'
end;
let exp =
- Builtin_attributes.warning_scope pvb_attributes
- (fun () -> type_expect exp_env sexp (mk_expected ty'))
+ Builtin_attributes.warning_scope pvb_attributes (fun () ->
+ if rec_flag = Recursive then
+ type_unpacks exp_env unpacks sexp (mk_expected ty')
+ else
+ type_expect exp_env sexp (mk_expected ty')
+ )
in
- end_def ();
- check_univars env true "definition" exp pat.pat_type vars;
- {exp with exp_type = instance exp.exp_type}
+ exp, Some vars
| _ ->
- Builtin_attributes.warning_scope pvb_attributes (fun () ->
- type_expect exp_env sexp (mk_expected pat.pat_type)))
+ let exp =
+ Builtin_attributes.warning_scope pvb_attributes (fun () ->
+ if rec_flag = Recursive then
+ type_unpacks exp_env unpacks sexp (mk_expected pat.pat_type)
+ else
+ type_expect exp_env sexp (mk_expected pat.pat_type))
+ in
+ exp, None)
spat_sexp_list pat_slot_list in
current_slot := None;
if is_recursive && not !rec_needed then begin
)
)
pat_list
- (List.map2 (fun (attrs, _) e -> attrs, e) spatl exp_list);
+ (List.map2 (fun (attrs, _) (e, _) -> attrs, e) spatl exp_list);
let pvs = List.map (fun pv -> { pv with pv_type = instance pv.pv_type}) pvs in
end_def();
List.iter2
- (fun pat exp ->
+ (fun pat (exp, _) ->
if maybe_expansive exp then
lower_contravariant env pat.pat_type)
pat_list exp_list;
iter_pattern_variables_type generalize pvs;
- (* We also generalize expressions that are not bound to a variable.
- This does not matter in general, but those types are shown by the
- interactive toplevel, for example: {[
- let _ = Array.get;;
- - : 'a array -> int -> 'a = <fun>
- ]} *)
- List.iter (fun exp -> generalize exp.exp_type) exp_list;
+ List.iter2
+ (fun pat (exp, vars) ->
+ match vars with
+ | None ->
+ (* We generalize expressions even if they are not bound to a variable
+ and do not have an expliclit polymorphic type annotation. This is
+ not needed in general, however those types may be shown by the
+ interactive toplevel, for example:
+ {[
+ let _ = Array.get;;
+ - : 'a array -> int -> 'a = <fun>
+ ]}
+ so we do it anyway. *)
+ generalize exp.exp_type
+ | Some vars ->
+ generalize_and_check_univars env "definition" exp pat.pat_type vars)
+ pat_list exp_list;
let l = List.combine pat_list exp_list in
let l =
List.map2
- (fun (p, e) pvb ->
+ (fun (p, (e, _)) pvb ->
{vb_pat=p; vb_expr=e; vb_attributes=pvb.pvb_attributes;
vb_loc=pvb.pvb_loc;
})
spellcheck ppf (Ident.name unbound) (List.map Ident.name valid_idents)
open Format
-open Printtyp
+
+let longident = Printtyp.longident
(* Returns the first diff of the trace *)
let type_clash_of_trace trace =
| Some (Texp_constant const) -> report_literal_type_constraint const diff
| _ -> []
-let report_pattern_type_clash_hints pat diff =
+let report_pattern_type_clash_hints
+ (type k) (pat : k pattern_desc option) diff =
match pat with
| Some (Tpat_constant const) -> report_literal_type_constraint const diff
| _ -> []
Location.errorf ~loc
"@[<v>@[<2>This function has type@ %a@]\
@ @[It is applied to too many arguments;@ %s@]@]"
- type_expr typ "maybe you forgot a `;'.";
+ Printtyp.type_expr typ "maybe you forgot a `;'.";
| _ ->
Location.errorf ~loc "@[<v>@[<2>This expression has type@ %a@]@ %s@]"
- type_expr typ
+ Printtyp.type_expr typ
"This is not a function; it cannot be applied."
end
- | Apply_wrong_label (l, ty) ->
+ | Apply_wrong_label (l, ty, extra_info) ->
let print_label ppf = function
| Nolabel -> fprintf ppf "without label"
| l -> fprintf ppf "with label %s" (prefixed_label_name l)
in
- Location.errorf ~loc
+ let extra_info =
+ if not extra_info then
+ []
+ else
+ [ Location.msg
+ "Since OCaml 4.11, optional arguments do not commute when \
+ -nolabels is given" ]
+ in
+ Location.errorf ~loc ~sub:extra_info
"@[<v>@[<2>The function applied to this argument has type@ %a@]@.\
This argument cannot be applied %a@]"
- type_expr ty print_label l
+ Printtyp.type_expr ty print_label l
| Label_multiply_defined s ->
Location.errorf ~loc "The record field label %s is defined several times"
s
print_labels labels
| Label_not_mutable lid ->
Location.errorf ~loc "The record field %a is not mutable" longident lid
- | Wrong_name (eorp, ty_expected, kind, p, name, valid_names) ->
+ | Wrong_name (eorp, ty_expected, { type_path; kind; name; valid_names; }) ->
Location.error_of_printer ~loc (fun ppf () ->
- let { ty; explanation } = ty_expected in
- if Path.is_constructor_typath p then begin
- fprintf ppf
- "@[The field %s is not part of the record \
- argument for the %a constructor@]"
- name
- path p;
- end else begin
- fprintf ppf
- "@[@[<2>%s type@ %a%t@]@ \
- The %s %s does not belong to type %a@]"
- eorp type_expr ty
- (report_type_expected_explanation_opt explanation)
- (label_of_kind kind)
- name (*kind*) path p;
- end;
- spellcheck ppf name valid_names
- ) ()
+ Printtyp.wrap_printing_env ~error:true env (fun () ->
+ let { ty; explanation } = ty_expected in
+ if Path.is_constructor_typath type_path then begin
+ fprintf ppf
+ "@[The field %s is not part of the record \
+ argument for the %a constructor@]"
+ name.txt
+ Printtyp.type_path type_path;
+ end else begin
+ fprintf ppf
+ "@[@[<2>%s type@ %a%t@]@ \
+ The %s %s does not belong to type %a@]"
+ eorp Printtyp.type_expr ty
+ (report_type_expected_explanation_opt explanation)
+ (Datatype_kind.label_name kind)
+ name.txt (*kind*) Printtyp.type_path type_path;
+ end;
+ spellcheck ppf name.txt valid_names
+ )) ()
| Name_type_mismatch (kind, lid, tp, tpl) ->
- let name = label_of_kind kind in
+ let type_name = Datatype_kind.type_name kind in
+ let name = Datatype_kind.label_name kind in
Location.error_of_printer ~loc (fun ppf () ->
- report_ambiguous_type_error ppf env tp tpl
+ Printtyp.report_ambiguous_type_error ppf env tp tpl
(function ppf ->
fprintf ppf "The %s %a@ belongs to the %s type"
- name longident lid kind)
+ name longident lid type_name)
(function ppf ->
fprintf ppf "The %s %a@ belongs to one of the following %s types:"
- name longident lid kind)
+ name longident lid type_name)
(function ppf ->
fprintf ppf "but a %s was expected belonging to the %s type"
- name kind)
+ name type_name)
) ()
| Invalid_format msg ->
Location.errorf ~loc "%s" msg
| Undefined_method (ty, me, valid_methods) ->
Location.error_of_printer ~loc (fun ppf () ->
- fprintf ppf
- "@[<v>@[This expression has type@;<1 2>%a@]@,\
- It has no method %s@]" type_expr ty me;
- begin match valid_methods with
- | None -> ()
- | Some valid_methods -> spellcheck ppf me valid_methods
- end
- ) ()
+ Printtyp.wrap_printing_env ~error:true env (fun () ->
+ fprintf ppf
+ "@[<v>@[This expression has type@;<1 2>%a@]@,\
+ It has no method %s@]" Printtyp.type_expr ty me;
+ begin match valid_methods with
+ | None -> ()
+ | Some valid_methods -> spellcheck ppf me valid_methods
+ end
+ )) ()
| Undefined_inherited_method (me, valid_methods) ->
Location.error_of_printer ~loc (fun ppf () ->
fprintf ppf "This expression has no method %s" me;
Location.errorf ~loc "The instance variable %s is not mutable" v
| Not_subtype(tr1, tr2) ->
Location.error_of_printer ~loc (fun ppf () ->
- report_subtyping_error ppf env tr1 "is not a subtype of" tr2
+ Printtyp.report_subtyping_error ppf env tr1 "is not a subtype of" tr2
) ()
| Outside_class ->
Location.errorf ~loc
Location.error_of_printer ~loc (fun ppf () ->
Printtyp.report_unification_error ppf env trace
(function ppf ->
- let ty, ty' = prepare_expansion (ty, ty') in
+ let ty, ty' = Printtyp.prepare_expansion (ty, ty') in
fprintf ppf "This expression cannot be coerced to type@;<1 2>%a;@ \
it has type"
- (type_expansion ty) ty')
+ (Printtyp.type_expansion ty) ty')
(function ppf ->
fprintf ppf "but is here used with type");
if b then
Location.errorf ~loc
"This function expects too many arguments,@ \
it should have type@ %a%t"
- type_expr ty
+ Printtyp.type_expr ty
(report_type_expected_explanation_opt explanation)
end else begin
Location.errorf ~loc
"This expression should not be a function,@ \
the expected type is@ %a%t"
- type_expr ty
+ Printtyp.type_expr ty
(report_type_expected_explanation_opt explanation)
end
| Abstract_wrong_label (l, ty, explanation) ->
(prefixed_label_name l) in
Location.errorf ~loc
"@[<v>@[<2>This function should have type@ %a%t@]@,%s@]"
- type_expr ty
+ Printtyp.type_expr ty
(report_type_expected_explanation_opt explanation)
(label_mark l)
| Scoping_let_module(id, ty) ->
Location.errorf ~loc
"This `let module' expression has type@ %a@ \
In this type, the locally bound module name %s escapes its scope"
- type_expr ty id
+ Printtyp.type_expr ty id
| Private_type ty ->
Location.errorf ~loc "Cannot create values of the private type %a"
- type_expr ty
+ Printtyp.type_expr ty
| Private_label (lid, ty) ->
Location.errorf ~loc "Cannot assign field %a of the private type %a"
- longident lid type_expr ty
+ longident lid Printtyp.type_expr ty
| Private_constructor (constr, ty) ->
Location.errorf ~loc
"Cannot use private constructor %s to create values of type %a"
- constr.cstr_name type_expr ty
+ constr.cstr_name Printtyp.type_expr ty
| Not_a_variant_type lid ->
Location.errorf ~loc "The type %a@ is not a variant type" longident lid
| Incoherent_label_order ->
| Not_a_packed_module ty ->
Location.errorf ~loc
"This expression is packed module, but the expected type is@ %a"
- type_expr ty
+ Printtyp.type_expr ty
| Unexpected_existential (reason, name, types) ->
let reason_str =
match reason with
fprintf ppf "These bindings have type")
(function ppf ->
fprintf ppf "but bindings were expected of type")
- | Empty_pattern -> assert false
let report_error ~loc env err =
- wrap_printing_env ~error:true env (fun () -> report_error ~loc env err)
+ Printtyp.wrap_printing_env ~error:true env
+ (fun () -> report_error ~loc env err)
let () =
Location.register_error_of_exn
val is_nonexpansive: Typedtree.expression -> bool
+module Datatype_kind : sig
+ type t = Record | Variant
+ val type_name : t -> string
+ val label_name : t -> string
+end
+
+type wrong_name = {
+ type_path: Path.t;
+ kind: Datatype_kind.t;
+ name: string loc;
+ valid_names: string list;
+}
+
type existential_restriction =
| At_toplevel (** no existential types at the toplevel *)
| In_group (** nor with [let ... and ...] *)
Env.t -> Parsetree.expression -> Typedtree.expression
val type_class_arg_pattern:
string -> Env.t -> Env.t -> arg_label -> Parsetree.pattern ->
- Typedtree.pattern * (Ident.t * Ident.t * type_expr) list *
+ Typedtree.pattern *
+ (Ident.t * Ident.t * type_expr) list *
Env.t * Env.t
val type_self_pattern:
string -> type_expr -> Env.t -> Env.t -> Env.t -> Parsetree.pattern ->
Env.t * Env.t * Env.t
val check_partial:
?lev:int -> Env.t -> type_expr ->
- Location.t -> Typedtree.case list -> Typedtree.partial
+ Location.t -> Typedtree.value Typedtree.case list -> Typedtree.partial
val type_expect:
?in_function:(Location.t * type_expr) ->
Env.t -> Parsetree.expression -> type_expected -> Typedtree.expression
val force_delayed_checks: unit -> unit
val name_pattern : string -> Typedtree.pattern list -> Ident.t
-
-val name_cases : string -> Typedtree.case list -> Ident.t
+val name_cases : string -> Typedtree.value Typedtree.case list -> Ident.t
val self_coercion : (Path.t * Location.t list ref) list ref
type error =
| Constructor_arity_mismatch of Longident.t * int * int
| Label_mismatch of Longident.t * Ctype.Unification_trace.t
- | Pattern_type_clash of
- Ctype.Unification_trace.t * Typedtree.pattern_desc option
+ | Pattern_type_clash :
+ Ctype.Unification_trace.t * _ Typedtree.pattern_desc option -> error
| Or_pattern_type_clash of Ident.t * Ctype.Unification_trace.t
| Multiply_bound_variable of string
| Orpat_vars of Ident.t * Ident.t list
Ctype.Unification_trace.t * type_forcing_context option
* Typedtree.expression_desc option
| Apply_non_function of type_expr
- | Apply_wrong_label of arg_label * type_expr
+ | Apply_wrong_label of arg_label * type_expr * bool
| Label_multiply_defined of string
| Label_missing of Ident.t list
| Label_not_mutable of Longident.t
- | Wrong_name of
- string * type_expected * string * Path.t * string * string list
+ | Wrong_name of string * type_expected * wrong_name
| Name_type_mismatch of
- string * Longident.t * (Path.t * Path.t) * (Path.t * Path.t) list
+ Datatype_kind.t * Longident.t * (Path.t * Path.t) * (Path.t * Path.t) list
| Invalid_format of string
| Undefined_method of type_expr * string * string list option
| Undefined_inherited_method of string * string list
| Illegal_letrec_pat
| Illegal_letrec_expr
| Illegal_class_expr
- | Empty_pattern
| Letop_type_clash of string * Ctype.Unification_trace.t
| Andop_type_clash of string * Ctype.Unification_trace.t
| Bindings_type_clash of Ctype.Unification_trace.t
| Constraint_failed of type_expr * type_expr
| Inconsistent_constraint of Env.t * Ctype.Unification_trace.t
| Type_clash of Env.t * Ctype.Unification_trace.t
- | Parameters_differ of Path.t * type_expr * type_expr
+ | Non_regular of {
+ definition: Path.t;
+ used_as: type_expr;
+ defined_as: type_expr;
+ expansions: (type_expr * type_expr) list;
+ }
| Null_arity_external
| Missing_native_external
| Unbound_type_var of type_expr * type_declaration
| Cannot_unbox_or_untag_type of native_repr_kind
| Deep_unbox_or_untag_attribute of native_repr_kind
| Immediacy of Typedecl_immediacy.error
+ | Separability of Typedecl_separability.error
| Bad_unboxed_attribute of string
- | Wrong_unboxed_type_float
| Boxed_and_unboxed
| Nonrec_gadt
Builtin_attributes.warning_scope ~ppwarning:false decl.type_attributes
(fun () -> Env.add_type ~check id decl env)
-let enter_type rec_flag env sdecl id =
+let enter_type rec_flag env sdecl (id, uid) =
let needed =
match rec_flag with
| Asttypes.Nonrecursive ->
Btype.is_row_name (Ident.name id)
| Asttypes.Recursive -> true
in
+ let arity = List.length sdecl.ptype_params in
if not needed then env else
let decl =
{ type_params =
List.map (fun _ -> Btype.newgenvar ()) sdecl.ptype_params;
- type_arity = List.length sdecl.ptype_params;
+ type_arity = arity;
type_kind = Type_abstract;
type_private = sdecl.ptype_private;
type_manifest =
begin match sdecl.ptype_manifest with None -> None
| Some _ -> Some(Ctype.newvar ()) end;
type_variance = List.map (fun _ -> Variance.full) sdecl.ptype_params;
+ type_separability = Types.Separability.default_signature ~arity;
type_is_newtype = false;
type_expansion_scope = Btype.lowest_level;
type_loc = sdecl.ptype_loc;
type_attributes = sdecl.ptype_attributes;
type_immediate = Unknown;
type_unboxed = unboxed_false_default_false;
+ type_uid = uid;
}
in
add_type ~check:true id decl env
ld_mutable = ld.ld_mutable;
ld_type = ty;
ld_loc = ld.ld_loc;
- ld_attributes = ld.ld_attributes
+ ld_attributes = ld.ld_attributes;
+ ld_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
}
)
lbls in
let args, targs =
transl_constructor_arguments env true sargs
in
- targs, None, args, None, type_params
+ targs, None, args, None
| Some sret_type ->
(* if it's a generalized constructor we must first narrow and
then widen so as to not introduce any new constraints *)
in
let tret_type = transl_simple_type env false sret_type in
let ret_type = tret_type.ctyp_type in
- let params =
- match (Ctype.repr ret_type).desc with
- | Tconstr (p', params, _) when Path.same type_path p' ->
- params
+ (* TODO add back type_path as a parameter ? *)
+ begin match (Ctype.repr ret_type).desc with
+ | Tconstr (p', _, _) when Path.same type_path p' -> ()
| _ ->
raise (Error (sret_type.ptyp_loc, Constraint_failed
(ret_type, Ctype.newconstr type_path type_params)))
- in
+ end;
widen z;
- targs, Some tret_type, args, Some ret_type, params
-
-(* Check that the variable [id] is present in the [univ] list. *)
-let check_type_var loc univ id =
- let f t = (Btype.repr t).id = id in
- if not (List.exists f univ) then raise (Error (loc, Wrong_unboxed_type_float))
-
-(* Check that all the variables found in [ty] are in [univ].
- Because [ty] is the argument to an abstract type, the representation
- of that abstract type could be any subexpression of [ty], in particular
- any type variable present in [ty].
-*)
-let rec check_unboxed_abstract_arg loc univ ty =
- match ty.desc with
- | Tvar _ -> check_type_var loc univ ty.id
- | Tarrow (_, t1, t2, _)
- | Tfield (_, _, t1, t2) ->
- check_unboxed_abstract_arg loc univ t1;
- check_unboxed_abstract_arg loc univ t2
- | Ttuple args
- | Tconstr (_, args, _)
- | Tpackage (_, _, args) ->
- List.iter (check_unboxed_abstract_arg loc univ) args
- | Tobject (fields, r) ->
- check_unboxed_abstract_arg loc univ fields;
- begin match !r with
- | None -> ()
- | Some (_, args) -> List.iter (check_unboxed_abstract_arg loc univ) args
- end
- | Tnil
- | Tunivar _ -> ()
- | Tlink e -> check_unboxed_abstract_arg loc univ e
- | Tsubst _ -> assert false
- | Tvariant { row_fields; row_more; row_name } ->
- List.iter (check_unboxed_abstract_row_field loc univ) row_fields;
- check_unboxed_abstract_arg loc univ row_more;
- begin match row_name with
- | None -> ()
- | Some (_, args) -> List.iter (check_unboxed_abstract_arg loc univ) args
- end
- | Tpoly (t, _) -> check_unboxed_abstract_arg loc univ t
-
-and check_unboxed_abstract_row_field loc univ (_, field) =
- match field with
- | Rpresent (Some ty) -> check_unboxed_abstract_arg loc univ ty
- | Reither (_, args, _, r) ->
- List.iter (check_unboxed_abstract_arg loc univ) args;
- begin match !r with
- | None -> ()
- | Some f -> check_unboxed_abstract_row_field loc univ ("", f)
- end
- | Rabsent
- | Rpresent None -> ()
+ targs, Some tret_type, args, Some ret_type
-(* Check that the argument to a GADT constructor is compatible with unboxing
- the type, given the universal parameters of the type. *)
-let rec check_unboxed_gadt_arg loc univ env ty =
- match get_unboxed_type_representation env ty with
- | Some {desc = Tvar _; id} -> check_type_var loc univ id
- | Some {desc = Tarrow _ | Ttuple _ | Tpackage _ | Tobject _ | Tnil
- | Tvariant _; _} ->
- ()
- (* A comment in [Translcore.transl_exp0] claims the above cannot be
- represented by floats. *)
- | Some {desc = Tconstr (p, args, _); _} ->
- let tydecl = Env.find_type p env in
- assert (not tydecl.type_unboxed.unboxed);
- if tydecl.type_kind = Type_abstract then
- List.iter (check_unboxed_abstract_arg loc univ) args
- | Some {desc = Tfield _ | Tlink _ | Tsubst _; _} -> assert false
- | Some {desc = Tunivar _; _} -> ()
- | Some {desc = Tpoly (t2, _); _} -> check_unboxed_gadt_arg loc univ env t2
- | None -> ()
- (* This case is tricky: the argument is another (or the same) type
- in the same recursive definition. In this case we don't have to
- check because we will also check that other type for correctness. *)
-
-let transl_declaration env sdecl id =
+let transl_declaration env sdecl (id, uid) =
(* Bind type parameters *)
reset_type_variables();
Ctype.begin_def ();
in
let raw_status = get_unboxed_from_attributes sdecl in
if raw_status.unboxed && not raw_status.default then begin
+ let bad msg = raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute msg)) in
match sdecl.ptype_kind with
- | Ptype_abstract ->
- raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute
- "it is abstract"))
- | Ptype_variant [{pcd_args = Pcstr_tuple []; _}] ->
- raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute
- "its constructor has no argument"))
- | Ptype_variant [{pcd_args = Pcstr_tuple [_]; _}] -> ()
- | Ptype_variant [{pcd_args = Pcstr_tuple _; _}] ->
- raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute
- "its constructor has more than one argument"))
- | Ptype_variant [{pcd_args = Pcstr_record
- [{pld_mutable=Immutable; _}]; _}] -> ()
- | Ptype_variant [{pcd_args = Pcstr_record [{pld_mutable=Mutable; _}]; _}] ->
- raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute "it is mutable"))
- | Ptype_variant [{pcd_args = Pcstr_record _; _}] ->
- raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute
- "its constructor has more than one argument"))
- | Ptype_variant _ ->
- raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute
- "it has more than one constructor"))
- | Ptype_record [{pld_mutable=Immutable; _}] -> ()
- | Ptype_record [{pld_mutable=Mutable; _}] ->
- raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute
- "it is mutable"))
- | Ptype_record _ ->
- raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute
- "it has more than one field"))
- | Ptype_open ->
- raise(Error(sdecl.ptype_loc, Bad_unboxed_attribute
- "extensible variant types cannot be unboxed"))
+ | Ptype_abstract -> bad "it is abstract"
+ | Ptype_open -> bad "extensible variant types cannot be unboxed"
+ | Ptype_record fields -> begin match fields with
+ | [] -> bad "it has no fields"
+ | _::_::_ -> bad "it has more than one field"
+ | [{pld_mutable = Mutable}] -> bad "it is mutable"
+ | [{pld_mutable = Immutable}] -> ()
+ end
+ | Ptype_variant constructors -> begin match constructors with
+ | [] -> bad "it has no constructor"
+ | (_::_::_) -> bad "it has more than one constructor"
+ | [c] -> begin match c.pcd_args with
+ | Pcstr_tuple [] ->
+ bad "its constructor has no argument"
+ | Pcstr_tuple (_::_::_) ->
+ bad "its constructor has more than one argument"
+ | Pcstr_tuple [_] ->
+ ()
+ | Pcstr_record [] ->
+ bad "its constructor has no fields"
+ | Pcstr_record (_::_::_) ->
+ bad "its constructor has more than one field"
+ | Pcstr_record [{pld_mutable = Mutable}] ->
+ bad "it is mutable"
+ | Pcstr_record [{pld_mutable = Immutable}] ->
+ ()
+ end
+ end
end;
let unboxed_status =
match sdecl.ptype_kind with
| Ptype_variant [{pcd_args = Pcstr_tuple [_]; _}]
- | Ptype_variant [{pcd_args = Pcstr_record
- [{pld_mutable = Immutable; _}]; _}]
- | Ptype_record [{pld_mutable = Immutable; _}] ->
- raw_status
- | _ -> (* The type is not unboxable, mark it as boxed *)
- unboxed_false_default_false
+ | Ptype_variant [{pcd_args = Pcstr_record [{pld_mutable=Immutable; _}]; _}]
+ | Ptype_record [{pld_mutable=Immutable; _}] -> raw_status
+ | _ -> unboxed_false_default_false (* Not unboxable, mark as boxed *)
in
let unbox = unboxed_status.unboxed in
let (tkind, kind) =
raise(Error(sdecl.ptype_loc, Too_many_constructors));
let make_cstr scstr =
let name = Ident.create_local scstr.pcd_name.txt in
- let targs, tret_type, args, ret_type, cstr_params =
+ let targs, tret_type, args, ret_type =
make_constructor env (Path.Pident id) params
scstr.pcd_args scstr.pcd_res
in
- if Config.flat_float_array && unbox then begin
- (* Cannot unbox a type when the argument can be both float and
- non-float because it interferes with the dynamic float array
- optimization. This can only happen when the type is a GADT
- and the argument is an existential type variable or an
- unboxed (or abstract) type constructor applied to some
- existential type variable. Of course we also have to rule
- out any abstract type constructor applied to anything that
- might be an existential type variable.
- There is a difficulty with existential variables created
- out of thin air (rather than bound by the declaration).
- See PR#7511 and GPR#1133 for details. *)
- match Datarepr.constructor_existentials args ret_type with
- | _, [] -> ()
- | [argty], _ex ->
- check_unboxed_gadt_arg sdecl.ptype_loc cstr_params env argty
- | _ -> assert false
- end;
let tcstr =
{ cd_id = name;
cd_name = scstr.pcd_name;
cd_args = args;
cd_res = ret_type;
cd_loc = scstr.pcd_loc;
- cd_attributes = scstr.pcd_attributes }
+ cd_attributes = scstr.pcd_attributes;
+ cd_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) }
in
tcstr, cstr
in
let cty = transl_simple_type env no_row sty in
Some cty, Some cty.ctyp_type
in
+ let arity = List.length params in
let decl =
{ type_params = params;
- type_arity = List.length params;
+ type_arity = arity;
type_kind = kind;
type_private = sdecl.ptype_private;
type_manifest = man;
type_variance = List.map (fun _ -> Variance.full) params;
+ type_separability = Types.Separability.default_signature ~arity;
type_is_newtype = false;
type_expansion_scope = Btype.lowest_level;
type_loc = sdecl.ptype_loc;
type_attributes = sdecl.ptype_attributes;
type_immediate = Unknown;
type_unboxed = unboxed_status;
+ type_uid = uid;
} in
(* Check constraints *)
let visited = ref [] in
- let rec check_regular cpath args prev_exp ty =
+ let rec check_regular cpath args prev_exp prev_expansions ty =
let ty = Ctype.repr ty in
if not (List.memq ty !visited) then begin
visited := ty :: !visited;
if Path.same path path' then begin
if not (Ctype.equal env false args args') then
raise (Error(loc,
- Parameters_differ(cpath, ty, Ctype.newconstr path args)))
+ Non_regular {
+ definition=path;
+ used_as=ty;
+ defined_as=Ctype.newconstr path args;
+ expansions=List.rev prev_expansions;
+ }))
end
(* Attempt to expand a type abbreviation if:
1- [to_check path'] holds
raise (Error(loc, Constraint_failed
(ty, Ctype.newconstr path' params0)));
end;
- check_regular path' args (path' :: prev_exp) body
+ check_regular path' args
+ (path' :: prev_exp) ((ty,body) :: prev_expansions)
+ body
with Not_found -> ()
end;
- List.iter (check_regular cpath args prev_exp) args'
+ List.iter (check_regular cpath args prev_exp prev_expansions) args'
| Tpoly (ty, tl) ->
let (_, ty) = Ctype.instance_poly ~keep_names:true false tl ty in
- check_regular cpath args prev_exp ty
+ check_regular cpath args prev_exp prev_expansions ty
| _ ->
- Btype.iter_type_expr (check_regular cpath args prev_exp) ty
+ Btype.iter_type_expr
+ (check_regular cpath args prev_exp prev_expansions) ty
end in
Option.iter
let (args, body) =
Ctype.instance_parameterized_type
~keep_names:true decl.type_params body in
- check_regular path args [] body)
+ check_regular path args [] [] body)
decl.type_manifest
let check_abbrev_recursion env id_loc_list to_check tdecl =
let id = tdecl.typ_id in
check_recursion env (List.assoc id id_loc_list) (Path.Pident id) decl to_check
-(* Check multiple declarations of labels/constructors *)
-
let check_duplicates sdecl_list =
let labels = Hashtbl.create 7 and constrs = Hashtbl.create 7 in
List.iter
(* Create identifiers. *)
let scope = Ctype.create_scope () in
- let id_list =
- List.map (fun sdecl -> Ident.create_scoped ~scope sdecl.ptype_name.txt)
- sdecl_list
+ let ids_list =
+ List.map (fun sdecl ->
+ Ident.create_scoped ~scope sdecl.ptype_name.txt,
+ Uid.mk ~current_unit:(Env.get_unit_name ())
+ ) sdecl_list
in
Ctype.begin_def();
(* Enter types. *)
let temp_env =
- List.fold_left2 (enter_type rec_flag) env sdecl_list id_list in
+ List.fold_left2 (enter_type rec_flag) env sdecl_list ids_list in
(* Translate each declaration. *)
let current_slot = ref None in
let warn_unused = Warnings.is_active (Warnings.Unused_type_declaration "") in
- let id_slots id =
+ let ids_slots (id, _uid as ids) =
match rec_flag with
| Asttypes.Recursive when warn_unused ->
(* See typecore.ml for a description of the algorithm used
to detect unused declarations in a set of recursive definitions. *)
let slot = ref [] in
let td = Env.find_type (Path.Pident id) temp_env in
- let name = Ident.name id in
Env.set_type_used_callback
- name td
+ td
(fun old_callback ->
match !current_slot with
- | Some slot -> slot := (name, td) :: !slot
+ | Some slot -> slot := td.type_uid :: !slot
| None ->
- List.iter (fun (name, d) -> Env.mark_type_used name d)
- (get_ref slot);
+ List.iter Env.mark_type_used (get_ref slot);
old_callback ()
);
- id, Some slot
+ ids, Some slot
| Asttypes.Recursive | Asttypes.Nonrecursive ->
- id, None
+ ids, None
in
let transl_declaration name_sdecl (id, slot) =
current_slot := slot;
(fun () -> transl_declaration temp_env name_sdecl id)
in
let tdecls =
- List.map2 transl_declaration sdecl_list (List.map id_slots id_list) in
+ List.map2 transl_declaration sdecl_list (List.map ids_slots ids_list) in
let decls =
List.map (fun tdecl -> (tdecl.typ_id, tdecl.typ_type)) tdecls in
current_slot := None;
| Asttypes.Nonrecursive -> ()
| Asttypes.Recursive ->
List.iter2
- (fun id sdecl -> update_type temp_env new_env id sdecl.ptype_loc)
- id_list sdecl_list
+ (fun (id, _) sdecl -> update_type temp_env new_env id sdecl.ptype_loc)
+ ids_list sdecl_list
end;
(* Generalize type declarations. *)
Ctype.end_def();
List.iter (fun (_, decl) -> generalize_decl decl) decls;
(* Check for ill-formed abbrevs *)
let id_loc_list =
- List.map2 (fun id sdecl -> (id, sdecl.ptype_loc))
- id_list sdecl_list
+ List.map2 (fun (id, _) sdecl -> (id, sdecl.ptype_loc))
+ ids_list sdecl_list
in
List.iter (fun (id, decl) ->
check_well_founded_manifest new_env (List.assoc id id_loc_list)
|> name_recursion_decls sdecl_list
|> Typedecl_variance.update_decls env sdecl_list
|> Typedecl_immediacy.update_decls env
+ |> Typedecl_separability.update_decls env
with
- | Typedecl_variance.Error (loc, err) -> raise (Error (loc, Variance err))
- | Typedecl_immediacy.Error (loc, err) -> raise (Error (loc, Immediacy err))
+ | Typedecl_variance.Error (loc, err) ->
+ raise (Error (loc, Variance err))
+ | Typedecl_immediacy.Error (loc, err) ->
+ raise (Error (loc, Immediacy err))
+ | Typedecl_separability.Error (loc, err) ->
+ raise (Error (loc, Separability err))
in
(* Compute the final environment with variance and immediacy *)
let final_env = add_types_to_env decls env in
let args, ret_type, kind =
match sext.pext_kind with
Pext_decl(sargs, sret_type) ->
- let targs, tret_type, args, ret_type, _ =
+ let targs, tret_type, args, ret_type =
make_constructor env type_path typext_params
sargs sret_type
in
ext_ret_type = ret_type;
ext_private = priv;
Types.ext_loc = sext.pext_loc;
- Types.ext_attributes = sext.pext_attributes; }
+ Types.ext_attributes = sext.pext_attributes;
+ ext_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
+ }
in
{ ext_id = id;
ext_name = sext.pext_name;
(fun () -> transl_extension_constructor env type_path type_params
typext_params priv sext)
+let is_rebind ext =
+ match ext.ext_kind with
+ | Text_rebind _ -> true
+ | Text_decl _ -> false
+
let transl_type_extension extend env loc styext =
reset_type_variables();
Ctype.begin_def();
let newenv =
List.fold_left
(fun env ext ->
- Env.add_extension ~check:true ext.ext_id ext.ext_type env)
+ let rebind = is_rebind ext in
+ Env.add_extension ~check:true ~rebind ext.ext_id ext.ext_type env)
env constructors
in
let tyext =
raise (Error(ext.ext_loc, Unbound_type_var_ext(ty, ext.ext_type)))
| None -> ()
end;
- let newenv = Env.add_extension ~check:true ext.ext_id ext.ext_type env in
+ let rebind = is_rebind ext in
+ let newenv =
+ Env.add_extension ~check:true ~rebind ext.ext_id ext.ext_type env
+ in
ext, newenv
let transl_type_exception env t =
match valdecl.pval_prim with
[] when Env.is_in_signature env ->
{ val_type = ty; val_kind = Val_reg; Types.val_loc = loc;
- val_attributes = valdecl.pval_attributes }
+ val_attributes = valdecl.pval_attributes;
+ val_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
+ }
| [] ->
raise (Error(valdecl.pval_loc, Val_in_structure))
| _ ->
then raise(Error(valdecl.pval_type.ptyp_loc, Missing_native_external));
check_unboxable env loc ty;
{ val_type = ty; val_kind = Val_prim prim; Types.val_loc = loc;
- val_attributes = valdecl.pval_attributes }
+ val_attributes = valdecl.pval_attributes;
+ val_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
+ }
in
let (id, newenv) =
Env.enter_value valdecl.pval_name.txt v env
(fun () -> transl_value_decl env loc valdecl)
(* Translate a "with" constraint -- much simplified version of
- transl_type_decl. *)
-let transl_with_constraint env id row_path orig_decl sdecl =
- Env.mark_type_used (Ident.name id) orig_decl;
+ transl_type_decl. For a constraint [Sig with t = sdecl],
+ there are two declarations of interest in two environments:
+ - [sig_decl] is the declaration of [t] in [Sig],
+ in the environment [sig_env] (containing the declarations
+ of [Sig] before [t])
+ - [sdecl] is the new syntactic declaration, to be type-checked
+ in the current, outer environment [with_env].
+
+ In particular, note that [sig_env] is an extension of
+ [outer_env].
+*)
+let transl_with_constraint id row_path ~sig_env ~sig_decl ~outer_env sdecl =
+ Env.mark_type_used sig_decl.type_uid;
reset_type_variables();
Ctype.begin_def();
+ (* In the first part of this function, we typecheck the syntactic
+ declaration [sdecl] in the outer environment [outer_env]. *)
+ let env = outer_env in
+ let loc = sdecl.ptype_loc in
let tparams = make_params env sdecl.ptype_params in
let params = List.map (fun (cty, _) -> cty.ctyp_type) tparams in
- let orig_decl = Ctype.instance_declaration orig_decl in
- let arity_ok = List.length params = orig_decl.type_arity in
- if arity_ok then
- List.iter2 (Ctype.unify_var env) params orig_decl.type_params;
- let constraints = List.map
- (function (ty, ty', loc) ->
- try
- let cty = transl_simple_type env false ty in
- let cty' = transl_simple_type env false ty' in
- let ty = cty.ctyp_type in
- let ty' = cty'.ctyp_type in
- Ctype.unify env ty ty';
- (cty, cty', loc)
- with Ctype.Unify tr ->
- raise(Error(loc, Inconsistent_constraint (env, tr))))
- sdecl.ptype_cstrs
+ let arity = List.length params in
+ let constraints =
+ List.map (fun (ty, ty', loc) ->
+ let cty = transl_simple_type env false ty in
+ let cty' = transl_simple_type env false ty' in
+ (* Note: We delay the unification of those constraints
+ after the unification of parameters, so that clashing
+ constraints report an error on the constraint location
+ rather than the parameter location. *)
+ (cty, cty', loc)
+ ) sdecl.ptype_cstrs
in
let no_row = not (is_fixed_type sdecl) in
let (tman, man) = match sdecl.ptype_manifest with
let cty = transl_simple_type env no_row sty in
Some cty, Some cty.ctyp_type
in
+ (* In the second part, we check the consistency between the two
+ declarations and compute a "merged" declaration; we now need to
+ work in the larger signature environment [sig_env], because
+ [sig_decl.type_params] and [sig_decl.type_kind] are only valid
+ there. *)
+ let env = sig_env in
+ let sig_decl = Ctype.instance_declaration sig_decl in
+ let arity_ok = arity = sig_decl.type_arity in
+ if arity_ok then
+ List.iter2 (fun (cty, _) tparam ->
+ try Ctype.unify_var env cty.ctyp_type tparam
+ with Ctype.Unify tr ->
+ raise(Error(cty.ctyp_loc, Inconsistent_constraint (env, tr)))
+ ) tparams sig_decl.type_params;
+ List.iter (fun (cty, cty', loc) ->
+ (* Note: contraints must also be enforced in [sig_env] because
+ they may contain parameter variables from [tparams]
+ that have now be unified in [sig_env]. *)
+ try Ctype.unify env cty.ctyp_type cty'.ctyp_type
+ with Ctype.Unify tr ->
+ raise(Error(loc, Inconsistent_constraint (env, tr)))
+ ) constraints;
let priv =
if sdecl.ptype_private = Private then Private else
- if arity_ok && orig_decl.type_kind <> Type_abstract
- then orig_decl.type_private else sdecl.ptype_private
+ if arity_ok && sig_decl.type_kind <> Type_abstract
+ then sig_decl.type_private else sdecl.ptype_private
in
- if arity_ok && orig_decl.type_kind <> Type_abstract
+ if arity_ok && sig_decl.type_kind <> Type_abstract
&& sdecl.ptype_private = Private then
- Location.deprecated sdecl.ptype_loc "spurious use of private";
+ Location.deprecated loc "spurious use of private";
let type_kind, type_unboxed =
if arity_ok && man <> None then
- orig_decl.type_kind, orig_decl.type_unboxed
+ sig_decl.type_kind, sig_decl.type_unboxed
else
Type_abstract, unboxed_false_default_false
in
- let decl =
+ let new_sig_decl =
{ type_params = params;
- type_arity = List.length params;
+ type_arity = arity;
type_kind;
type_private = priv;
type_manifest = man;
type_variance = [];
+ type_separability = Types.Separability.default_signature ~arity;
type_is_newtype = false;
type_expansion_scope = Btype.lowest_level;
- type_loc = sdecl.ptype_loc;
+ type_loc = loc;
type_attributes = sdecl.ptype_attributes;
type_immediate = Unknown;
type_unboxed;
+ type_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
}
in
begin match row_path with None -> ()
- | Some p -> set_fixed_row env sdecl.ptype_loc p decl
+ | Some p -> set_fixed_row env loc p new_sig_decl
end;
- begin match Ctype.closed_type_decl decl with None -> ()
- | Some ty -> raise(Error(sdecl.ptype_loc, Unbound_type_var(ty,decl)))
+ begin match Ctype.closed_type_decl new_sig_decl with None -> ()
+ | Some ty -> raise(Error(loc, Unbound_type_var(ty, new_sig_decl)))
end;
- let decl = name_recursion sdecl id decl in
- let type_variance =
- try Typedecl_variance.compute_decl
- env ~check:true decl (Typedecl_variance.variance_of_sdecl sdecl)
+ let new_sig_decl = name_recursion sdecl id new_sig_decl in
+ let new_type_variance =
+ let required = Typedecl_variance.variance_of_sdecl sdecl in
+ try
+ Typedecl_variance.compute_decl env ~check:true new_sig_decl required
with Typedecl_variance.Error (loc, err) ->
raise (Error (loc, Variance err)) in
- let type_immediate =
+ let new_type_immediate =
(* Typedecl_immediacy.compute_decl never raises *)
- Typedecl_immediacy.compute_decl env decl in
- let decl = {decl with type_variance; type_immediate} in
+ Typedecl_immediacy.compute_decl env new_sig_decl in
+ let new_type_separability =
+ try Typedecl_separability.compute_decl env new_sig_decl
+ with Typedecl_separability.Error (loc, err) ->
+ raise (Error (loc, Separability err)) in
+ let new_sig_decl =
+ (* we intentionally write this without a fragile { decl with ... }
+ to ensure that people adding new fields to type declarations
+ consider whether they need to recompute it here; for an example
+ of bug caused by the previous approach, see #9607 *)
+ {
+ type_params = new_sig_decl.type_params;
+ type_arity = new_sig_decl.type_arity;
+ type_kind = new_sig_decl.type_kind;
+ type_private = new_sig_decl.type_private;
+ type_manifest = new_sig_decl.type_manifest;
+ type_unboxed = new_sig_decl.type_unboxed;
+ type_is_newtype = new_sig_decl.type_is_newtype;
+ type_expansion_scope = new_sig_decl.type_expansion_scope;
+ type_loc = new_sig_decl.type_loc;
+ type_attributes = new_sig_decl.type_attributes;
+ type_uid = new_sig_decl.type_uid;
+
+ type_variance = new_type_variance;
+ type_immediate = new_type_immediate;
+ type_separability = new_type_separability;
+ } in
Ctype.end_def();
- generalize_decl decl;
+ generalize_decl new_sig_decl;
{
typ_id = id;
typ_name = sdecl.ptype_name;
typ_params = tparams;
- typ_type = decl;
+ typ_type = new_sig_decl;
typ_cstrs = constraints;
- typ_loc = sdecl.ptype_loc;
+ typ_loc = loc;
typ_manifest = tman;
typ_kind = Ttype_abstract;
typ_private = sdecl.ptype_private;
type_private = Public;
type_manifest = None;
type_variance = replicate_list Variance.full arity;
+ type_separability = Types.Separability.default_signature ~arity;
type_is_newtype = false;
type_expansion_scope = Btype.lowest_level;
type_loc = Location.none;
type_attributes = [];
type_immediate = Unknown;
type_unboxed = unboxed_false_default_false;
+ type_uid = Uid.internal_not_actually_unique;
} in
Ctype.end_def();
generalize_decl decl;
"Constraints are not satisfied in this type."
!Oprint.out_type (Printtyp.tree_of_typexp false ty)
!Oprint.out_type (Printtyp.tree_of_typexp false ty')
- | Parameters_differ (path, ty, ty') ->
- Printtyp.reset_and_mark_loops ty;
- Printtyp.mark_loops ty';
+ | Non_regular { definition; used_as; defined_as; expansions } ->
+ let pp_expansion ppf (ty,body) =
+ Format.fprintf ppf "%a = %a"
+ Printtyp.type_expr ty
+ Printtyp.type_expr body in
+ let comma ppf () = Format.fprintf ppf ",@;<1 2>" in
+ let pp_expansions ppf expansions =
+ Format.(pp_print_list ~pp_sep:comma pp_expansion) ppf expansions in
+ Printtyp.reset_and_mark_loops used_as;
+ Printtyp.mark_loops defined_as;
Printtyp.Naming_context.reset ();
- fprintf ppf
- "@[<hv>In the definition of %s, type@ %a@ should be@ %a@]"
- (Path.name path)
- !Oprint.out_type (Printtyp.tree_of_typexp false ty)
- !Oprint.out_type (Printtyp.tree_of_typexp false ty')
+ begin match expansions with
+ | [] ->
+ fprintf ppf
+ "@[<hv>This recursive type is not regular.@ \
+ The type constructor %s is defined as@;<1 2>type %a@ \
+ but it is used as@;<1 2>%a.@ \
+ All uses need to match the definition for the recursive type \
+ to be regular.@]"
+ (Path.name definition)
+ !Oprint.out_type (Printtyp.tree_of_typexp false defined_as)
+ !Oprint.out_type (Printtyp.tree_of_typexp false used_as)
+ | _ :: _ ->
+ fprintf ppf
+ "@[<hv>This recursive type is not regular.@ \
+ The type constructor %s is defined as@;<1 2>type %a@ \
+ but it is used as@;<1 2>%a@ \
+ after the following expansion(s):@;<1 2>%a@ \
+ All uses need to match the definition for the recursive type \
+ to be regular.@]"
+ (Path.name definition)
+ !Oprint.out_type (Printtyp.tree_of_typexp false defined_as)
+ !Oprint.out_type (Printtyp.tree_of_typexp false used_as)
+ pp_expansions expansions
+ end
| Inconsistent_constraint (env, trace) ->
fprintf ppf "The type constraints are not consistent.@.";
Printtyp.report_unification_error ppf env trace
produced using the Stdlib.Sys.Immediate64.Make functor.")
| Bad_unboxed_attribute msg ->
fprintf ppf "@[This type cannot be unboxed because@ %s.@]" msg
- | Wrong_unboxed_type_float ->
+ | Separability (Typedecl_separability.Non_separable_evar evar) ->
+ let pp_evar ppf = function
+ | None ->
+ fprintf ppf "an unnamed existential variable"
+ | Some str ->
+ fprintf ppf "the existential variable %a"
+ Pprintast.tyvar str in
fprintf ppf "@[This type cannot be unboxed because@ \
- it might contain both float and non-float values.@ \
+ it might contain both float and non-float values,@ \
+ depending on the instantiation of %a.@ \
You should annotate it with [%@%@ocaml.boxed].@]"
+ pp_evar evar
| Boxed_and_unboxed ->
fprintf ppf "@[A type cannot be boxed and unboxed at the same time.@]"
| Nonrec_gadt ->
Parsetree.value_description -> Typedtree.value_description * Env.t
val transl_with_constraint:
- Env.t -> Ident.t -> Path.t option -> Types.type_declaration ->
- Parsetree.type_declaration -> Typedtree.type_declaration
+ Ident.t -> Path.t option ->
+ sig_env:Env.t -> sig_decl:Types.type_declaration ->
+ outer_env:Env.t -> Parsetree.type_declaration ->
+ Typedtree.type_declaration
val abstract_type_decl: int -> type_declaration
val approx_type_decl:
| Constraint_failed of type_expr * type_expr
| Inconsistent_constraint of Env.t * Ctype.Unification_trace.t
| Type_clash of Env.t * Ctype.Unification_trace.t
- | Parameters_differ of Path.t * type_expr * type_expr
+ | Non_regular of {
+ definition: Path.t;
+ used_as: type_expr;
+ defined_as: type_expr;
+ expansions: (type_expr * type_expr) list;
+ }
| Null_arity_external
| Missing_native_external
| Unbound_type_var of type_expr * type_declaration
| Cannot_unbox_or_untag_type of native_repr_kind
| Deep_unbox_or_untag_attribute of native_repr_kind
| Immediacy of Typedecl_immediacy.error
+ | Separability of Typedecl_separability.error
| Bad_unboxed_attribute of string
- | Wrong_unboxed_type_float
| Boxed_and_unboxed
| Nonrec_gadt
--- /dev/null
+(**************************************************************************)
+(* *)
+(* OCaml *)
+(* *)
+(* Gabriel Scherer, projet Parsifal, INRIA Saclay *)
+(* Rodolphe Lepigre, projet Deducteam, INRIA Saclay *)
+(* *)
+(* Copyright 2018 Institut National de Recherche en Informatique et *)
+(* en Automatique. *)
+(* *)
+(* All rights reserved. This file is distributed under the terms of *)
+(* the GNU Lesser General Public License version 2.1, with the *)
+(* special exception on linking described in the file LICENSE. *)
+(* *)
+(**************************************************************************)
+
+open Types
+
+type type_definition = type_declaration
+(* We should use 'declaration' for interfaces, and 'definition' for
+ implementations. The name type_declaration in types.ml is improper
+ for our usage -- although for OCaml types the declaration and
+ definition languages are the same. *)
+
+(** assuming that a datatype has a single constructor/label with
+ a single argument, [argument_to_unbox] represents the
+ information we need to check the argument for separability. *)
+type argument_to_unbox = {
+ kind: parameter_kind; (* for error messages *)
+ mutability: Asttypes.mutable_flag;
+ argument_type: type_expr;
+ result_type_parameter_instances: type_expr list;
+ (** result_type_parameter_instances represents the domain of the
+ constructor; usually it is just a list of the datatype parameter
+ ('a, 'b, ...), but when using GADTs or constraints it could
+ contain arbitrary type expressions.
+
+ For example, [type 'a t = 'b constraint 'a = 'b * int] has
+ [['b * int]] as [result_type_parameter_instances], and so does
+ [type _ t = T : 'b -> ('b * int) t]. *)
+ location : Location.t;
+}
+and parameter_kind =
+ | Record_field
+ | Constructor_parameter
+ | Constructor_field (** inlined records *)
+
+(** ['a multiplicity] counts the number of ['a] in
+ a structure in which expect to see only one ['a]. *)
+type 'a multiplicity =
+ | Zero
+ | One of 'a
+ | Several
+
+type arity = argument_to_unbox multiplicity (**how many parameters?*)
+
+type branching = arity multiplicity (**how many constructors?*)
+
+(** Summarize the right-hand-side of a type declaration,
+ for separability-checking purposes. See {!structure} below. *)
+type type_structure =
+ | Synonym of type_expr
+ | Abstract
+ | Open
+ | Algebraic of branching
+
+let demultiply_list
+ : type a b. a list -> (a -> b) -> b multiplicity
+ = fun li f -> match li with
+ | [] -> Zero
+ | [v] -> One (f v)
+ | _::_::_ -> Several
+
+let structure : type_definition -> type_structure = fun def ->
+ match def.type_kind with
+ | Type_open -> Open
+ | Type_abstract ->
+ begin match def.type_manifest with
+ | None -> Abstract
+ | Some type_expr -> Synonym type_expr
+ end
+ | Type_record (labels, _) ->
+ Algebraic (One (
+ demultiply_list labels @@ fun ld -> {
+ location = ld.ld_loc;
+ kind = Record_field;
+ mutability = ld.ld_mutable;
+ argument_type = ld.ld_type;
+ result_type_parameter_instances = def.type_params;
+ }
+ ))
+ | Type_variant constructors ->
+ Algebraic (demultiply_list constructors @@ fun cd ->
+ let result_type_parameter_instances =
+ match cd.cd_res with
+ (* cd_res is the optional return type (in a GADT);
+ if None, just use the type parameters *)
+ | None -> def.type_params
+ | Some ret_type ->
+ begin match Ctype.repr ret_type with
+ | {desc=Tconstr (_, tyl, _)} ->
+ List.map Ctype.repr tyl
+ | _ -> assert false
+ end
+ in
+ begin match cd.cd_args with
+ | Cstr_tuple tys ->
+ demultiply_list tys @@ fun argument_type -> {
+ location = cd.cd_loc;
+ kind = Constructor_parameter;
+ mutability = Asttypes.Immutable;
+ argument_type;
+ result_type_parameter_instances;
+ }
+ | Cstr_record labels ->
+ demultiply_list labels @@ fun ld ->
+ let argument_type = ld.ld_type in
+ {
+ location = ld.ld_loc;
+ kind = Constructor_field;
+ mutability = ld.ld_mutable;
+ argument_type;
+ result_type_parameter_instances;
+ }
+ end)
+
+
+type error =
+ | Non_separable_evar of string option
+
+exception Error of Location.t * error
+
+(* see the .mli file for explanations on the modes *)
+module Sep = Types.Separability
+type mode = Sep.t = Ind | Sep | Deepsep
+
+let rank = Sep.rank
+let max_mode = Sep.max
+
+(** If the type context [e(_)] imposes the mode [m] on its hole [_],
+ and the type context [e'(_)] imposes the mode [m'] on its hole [_],
+ then the mode on [_] imposed by the context composition [e(e'(_))]
+ is [compose m m'].
+
+ This operation differs from [max_mode]: [max_mode Ind Sep] is [Sep],
+ but [compose Ind Sep] is [Ind]. *)
+let compose
+ : mode -> mode -> mode
+ = fun m1 m2 ->
+ match m1 with
+ | Deepsep -> Deepsep
+ | Sep -> m2
+ | Ind -> Ind
+
+type type_var = {
+ text: string option; (** the user name of the type variable, None for '_' *)
+ id: int; (** the identifier of the type node (type_expr.id) of the variable *)
+}
+
+module TVarMap = Map.Make(struct
+ type t = type_var
+ let compare v1 v2 = compare v1.id v2.id
+ end)
+type context = mode TVarMap.t
+let (++) = TVarMap.union (fun _ m1 m2 -> Some(max_mode m1 m2))
+let empty = TVarMap.empty
+
+
+(** [immediate_subtypes ty] returns the list of all the
+ immediate sub-type-expressions of [ty]. They represent the biggest
+ sub-components that may be extracted using a constraint. For
+ example, the immediate sub-type-expressions of [int * (bool * 'a)]
+ are [int] and [bool * 'a].
+
+ Smaller components are extracted recursively in [check_type]. *)
+let rec immediate_subtypes : type_expr -> type_expr list = fun ty ->
+ (* Note: Btype.fold_type_expr is not suitable here:
+ - it does not do the right thing on Tpoly, iterating on type
+ parameters as well as the subtype
+ - it performs a shallow traversal of object types,
+ while our implementation collects all method types *)
+ match (Ctype.repr ty).desc with
+ (* these are the important cases,
+ on which immediate_subtypes is called from [check_type] *)
+ | Tarrow(_,ty1,ty2,_) ->
+ [ty1; ty2]
+ | Ttuple(tys)
+ | Tpackage(_,_,tys) ->
+ tys
+ | Tobject(row,class_ty) ->
+ let class_subtys =
+ match !class_ty with
+ | None -> []
+ | Some(_,tys) -> tys
+ in
+ immediate_subtypes_object_row class_subtys row
+ | Tvariant(row) ->
+ immediate_subtypes_variant_row [] row
+
+ (* the cases below are not called from [check_type],
+ they are here for completeness *)
+ | Tnil | Tfield _ ->
+ (* these should only occur under Tobject and not at the toplevel,
+ but "better safe than sorry" *)
+ immediate_subtypes_object_row [] ty
+ | Tlink _ | Tsubst _ -> assert false (* impossible due to Ctype.repr *)
+ | Tvar _ | Tunivar _ -> []
+ | Tpoly (pty, _) -> [pty]
+ | Tconstr (_path, tys, _) -> tys
+
+and immediate_subtypes_object_row acc ty = match (Ctype.repr ty).desc with
+ | Tnil -> acc
+ | Tfield (_label, _kind, ty, rest) ->
+ let acc = ty :: acc in
+ immediate_subtypes_object_row acc rest
+ | _ -> ty :: acc
+
+and immediate_subtypes_variant_row acc desc =
+ let add_subtypes acc =
+ let add_subtype acc (_l, rf) =
+ immediate_subtypes_variant_row_field acc rf in
+ List.fold_left add_subtype acc desc.row_fields in
+ let add_row acc =
+ let row = Ctype.repr desc.row_more in
+ match row.desc with
+ | Tvariant more -> immediate_subtypes_variant_row acc more
+ | _ -> row :: acc
+ in
+ add_row (add_subtypes acc)
+
+and immediate_subtypes_variant_row_field acc = function
+ | Rpresent(None)
+ | Rabsent -> acc
+ | Rpresent(Some(ty)) -> ty :: acc
+ | Reither(_,field_types,_,r) ->
+ let acc = List.rev_append field_types acc in
+ begin match !r with
+ | None -> acc
+ | Some rf -> immediate_subtypes_variant_row_field acc rf
+ end
+
+let free_variables ty =
+ Ctype.free_variables (Ctype.repr ty)
+ |> List.map (fun {desc; id; _} ->
+ match desc with
+ | Tvar text -> {text; id}
+ | _ ->
+ (* Ctype.free_variables only returns Tvar nodes *)
+ assert false)
+
+(** Coinductive hypotheses to handle equi-recursive types
+
+ OCaml allows infinite/cyclic types, such as
+ (int * 'a) as 'a
+ whose infinite unfolding is (int * (int * (int * (int * ...)))).
+
+ Remark: this specific type is only accepted if the -rectypes option
+ is passed, but such "equi-recursive types" are accepted by
+ default if the cycle goes through an object type or polymorphic
+ variant type:
+ [ `int | `other of 'a ] as 'a
+ < head : int; rest : 'a > as 'a
+
+ We have to take those infinite types in account in our
+ separability-checking program: a naive implementation would loop
+ infinitely when trying to prove that one of them is Deepsep.
+
+ After type-checking, the cycle-introducing form (... as 'a) does
+ not appear explicitly in the syntax of types: types are graphs/trees
+ with cycles in them, and we have to use the type_expr.id field,
+ an identifier for each node in the graph/tree, to detect cycles.
+
+ We avoid looping by remembering the set of separability queries
+ that we have already asked ourselves (in the current
+ search branch). For example, if we are asked to check
+
+ (int * 'a) : Deepsep
+
+ our algorithm will check both (int : Deepsep) and ('a : Deepsep),
+ but it will remember in these sub-checks that it is in the process
+ of checking (int * 'a) : Deepsep, adding it to a list of "active
+ goals", or "coinductive hypotheses".
+
+ Each new sub-query will start by checking whether the query
+ already appears as a coinductive hypothesis; in our example, this
+ can happen if 'a and (int * 'a) are in fact the same node in the
+ cyclic tree. In that case, we return immediately (instead of looping):
+ we reason that, assuming that 'a is indeed Deepsep, then it is
+ the case that (int * 'a) is also Deepsep.
+
+ This kind of cyclic reasoning can be dangerous: it would be wrong
+ to argue that an arbitrary 'a type is Deepsep by saying:
+ "assuming that 'a is Deepsep, then it is the case that 'a is
+ also Deepsep". In the first case, we made an assumption on 'a,
+ and used it on a type (int * 'a) which has 'a as a strict sub-component;
+ in the second, we use it on the same type 'a directly, which is invalid.
+
+ Now consider a type of the form (('a t) as 'a): while 'a is a sub-component
+ of ('a t), it may still be wrong to reason coinductively about it,
+ as ('a t) may be defined as (type 'a t = 'a).
+
+ When moving from (int * 'a) to a subcomponent (int) or ('a), we
+ say that the coinductive hypothesis on (int * 'a : m) is "safe":
+ it can be used immediately to prove the subcomponents, because we
+ made progress moving to a strict subcomponent (we are guarded
+ under a computational type constructor). On the other hand, when
+ moving from ('a t) to ('a), we say that the coinductive hypothesis
+ ('a t : m) is "unsafe" for the subgoal, as we don't know whether
+ we have made strict progress. In the general case, we keep track
+ of a set of safe and unsafe hypotheses made in the past, and we
+ use them to terminate checking if we encounter them again,
+ ensuring termination.
+
+ If we encounter a (ty : m) goal that is exactly a safe hypothesis,
+ we terminate with a success. In fact, we can use mode subtyping here:
+ if (ty : m') appears as a hypothesis with (m' >= m), then we would
+ succeed for (ty : m'), so (ty : m) should succeed as well.
+
+ On the other hand, if we encounter a (ty : m) goal that is an
+ *unsafe* hypothesis, we terminate the check with a failure. In this case,
+ we cannot work modulo mode subtyping: if (ty : m') appears with
+ (m' >= m), then the check (ty : m') would have failed, but it is still
+ possible that the weaker current query (ty : m) would succeed.
+
+ In usual coinductive-reasoning systems, unsafe hypotheses are turned
+ into safe hypotheses each time strict progress is made (for each
+ guarded sub-goal). Consider ((int * 'a) t as 'a : deepsep) for example:
+ the idea is that the ((int * 'a) t : deepsep) hypothesis would be
+ unsafe when checking ((int * 'a) : deepsep), but that the progress
+ step from (int * 'a : deepsep) to ('a : deepsep) would turn all
+ past unsafe hypotheses into safe hypotheses. There is a problem
+ with this, though, due to constraints: what if (_ t) is defined as
+
+ type 'b t = 'a constraint 'b = (int * 'a)
+
+ ?
+
+ In that case, then 'a is precisely the one-step unfolding
+ of the ((int * 'a) t) definition, and it would be an invalid,
+ cyclic reasoning to prove ('a : deepsep) from the now-safe
+ hypothesis ((int * 'a) t : deepsep).
+
+ Surprisingly-fortunately, we have exactly the information we need
+ to know whether (_ t) may or may not pull a constraint trick of
+ this nature: we can look at its mode signature, where constraints
+ are marked by a Deepsep mode. If we see Deepsep, we know that a
+ constraint exists, but we don't know what the constraint is:
+ we cannot tell at which point, when decomposing the parameter type,
+ a sub-component can be considered safe again. To model this,
+ we add a third category of co-inductive hypotheses: to "safe" and
+ "unsafe" we add the category of "poison" hypotheses, which remain
+ poisonous during the remaining of the type decomposition,
+ even in presence of safe, computational types constructors:
+
+ - when going under a computational constructor,
+ "unsafe" hypotheses become "safe"
+ - when going under a constraining type (more precisely, under
+ a type parameter that is marked Deepsep in the mode signature),
+ "unsafe" hypotheses become "poison"
+
+ The mode signature tells us even a bit more: if a parameter
+ is marked "Ind", we know that the type constructor cannot unfold
+ to this parameter (otherwise it would be Sep), so going under
+ this parameter can be considered a safe/guarded move: if
+ we have to check (foo t : m) with ((_ : Ind) t) in the signature,
+ we can recursively check (foo : Ind) with (foo t : m) marked
+ as "safe", rather than "unsafe".
+*)
+module TypeMap = Btype.TypeMap
+module ModeSet = Set.Make(Types.Separability)
+
+type coinductive_hyps = {
+ safe: ModeSet.t TypeMap.t;
+ unsafe: ModeSet.t TypeMap.t;
+ poison: ModeSet.t TypeMap.t;
+}
+
+module Hyps : sig
+ type t = coinductive_hyps
+ val empty : t
+ val add : type_expr -> mode -> t -> t
+ val guard : t -> t
+ val poison : t -> t
+ val safe : type_expr -> mode -> t -> bool
+ val unsafe : type_expr -> mode -> t -> bool
+end = struct
+ type t = coinductive_hyps
+
+ let empty = {
+ safe = TypeMap.empty;
+ unsafe = TypeMap.empty;
+ poison = TypeMap.empty;
+ }
+
+ let of_opt = function
+ | Some ms -> ms
+ | None -> ModeSet.empty
+
+ let merge map1 map2 =
+ TypeMap.merge (fun _k ms1 ms2 ->
+ Some (ModeSet.union (of_opt ms1) (of_opt ms2))
+ ) map1 map2
+
+ let guard {safe; unsafe; poison;} = {
+ safe = merge safe unsafe;
+ unsafe = TypeMap.empty;
+ poison;
+ }
+
+ let poison {safe; unsafe; poison;} = {
+ safe;
+ unsafe = TypeMap.empty;
+ poison = merge poison unsafe;
+ }
+
+ let add ty m hyps =
+ let m_map = TypeMap.singleton ty (ModeSet.singleton m) in
+ { hyps with unsafe = merge m_map hyps.unsafe; }
+
+ let find ty map = try TypeMap.find ty map with Not_found -> ModeSet.empty
+
+ let safe ty m hyps =
+ match ModeSet.max_elt_opt (find ty hyps.safe) with
+ | None -> false
+ | Some best_safe -> rank best_safe >= rank m
+
+ let unsafe ty m {safe = _; unsafe; poison} =
+ let in_map s = ModeSet.mem m (find ty s) in
+ List.exists in_map [unsafe; poison]
+end
+
+(** For a type expression [ty] (without constraints and existentials),
+ any mode checking [ty : m] is satisfied in the "worse case" context
+ that maps all free variables of [ty] to the most demanding mode,
+ Deepsep. *)
+let worst_case ty =
+ let add ctx tvar = TVarMap.add tvar Deepsep ctx in
+ List.fold_left add TVarMap.empty (free_variables ty)
+
+
+(** [check_type env sigma ty m] returns the most permissive context [gamma]
+ such that [ty] is separable at mode [m] in [gamma], under
+ the signature [sigma]. *)
+let check_type
+ : Env.t -> type_expr -> mode -> context
+ = fun env ty m ->
+ let rec check_type hyps ty m =
+ let ty = Ctype.repr ty in
+ if Hyps.safe ty m hyps then empty
+ else if Hyps.unsafe ty m hyps then worst_case ty
+ else
+ let hyps = Hyps.add ty m hyps in
+ match (ty.desc, m) with
+ (* Impossible case due to the call to [Ctype.repr]. *)
+ | (Tlink _ , _ ) -> assert false
+ (* Impossible case (according to comment in [typing/types.mli]. *)
+ | (Tsubst(_) , _ ) -> assert false
+ (* "Indifferent" case, the empty context is sufficient. *)
+ | (_ , Ind ) -> empty
+ (* Variable case, add constraint. *)
+ | (Tvar(alpha) , m ) ->
+ TVarMap.singleton {text = alpha; id = ty.Types.id} m
+ (* "Separable" case for constructors with known memory representation. *)
+ | (Tarrow _ , Sep )
+ | (Ttuple _ , Sep )
+ | (Tvariant(_) , Sep )
+ | (Tobject(_,_) , Sep )
+ | ((Tnil | Tfield _) , Sep )
+ | (Tpackage(_,_,_) , Sep ) -> empty
+ (* "Deeply separable" case for these same constructors. *)
+ | (Tarrow _ , Deepsep)
+ | (Ttuple _ , Deepsep)
+ | (Tvariant(_) , Deepsep)
+ | (Tobject(_,_) , Deepsep)
+ | ((Tnil | Tfield _) , Deepsep)
+ | (Tpackage(_,_,_) , Deepsep) ->
+ let tys = immediate_subtypes ty in
+ let on_subtype context ty =
+ context ++ check_type (Hyps.guard hyps) ty Deepsep in
+ List.fold_left on_subtype empty tys
+ (* Polymorphic type, and corresponding polymorphic variable.
+
+ In theory, [Tpoly] (forall alpha. tau) would add a new variable
+ (alpha) in scope, check its body (tau) recursively, and then
+ remove the new variable from the resulting context. Because the
+ rule accepts any mode for this variable, the removal never
+ fails.
+
+ In practice the implementation is simplified by ignoring the
+ new variable, and always returning the [empty] context
+ (instead of (alpha : m) in the [Tunivar] case: the constraint
+ on the variable is removed/ignored at the variable occurrence
+ site, rather than at the variable-introduction site. *)
+ (* Note: that we are semantically incomplete in the Deepsep case
+ (following the syntactic typing rules): the semantics only
+ requires that *closed* sub-type-expressions be (deeply)
+ separable; sub-type-expressions containing the quantified
+ variable cannot be extracted by constraints (this would be
+ a scope violation), so they could be ignored if they occur
+ under a separating type constructor. *)
+ | (Tpoly(pty,_) , m ) ->
+ check_type hyps pty m
+ | (Tunivar(_) , _ ) -> empty
+ (* Type constructor case. *)
+ | (Tconstr(path,tys,_), m ) ->
+ let msig = (Env.find_type path env).type_separability in
+ let on_param context (ty, m_param) =
+ let hyps = match m_param with
+ | Ind -> Hyps.guard hyps
+ | Sep -> hyps
+ | Deepsep -> Hyps.poison hyps in
+ context ++ check_type hyps ty (compose m m_param) in
+ List.fold_left on_param empty (List.combine tys msig)
+ in
+ check_type Hyps.empty ty m
+
+let best_msig decl = List.map (fun _ -> Ind) decl.type_params
+let worst_msig decl = List.map (fun _ -> Deepsep) decl.type_params
+
+(** [msig_of_external_type decl] infers the mode signature of an
+ abstract/external type. We must assume the worst, namely that this
+ type may be defined as an unboxed algebraic datatype imposing deep
+ separability of its parameters.
+
+ One exception is when the type is marked "immediate", which
+ guarantees that its representation is only integers. Immediate
+ types are always separable, so [Ind] suffices for their
+ parameters.
+
+ Note: this differs from {!Types.Separability.default_signature},
+ which does not have access to the declaration and its immediacy. *)
+let msig_of_external_type decl =
+ match decl.type_immediate with
+ | Always | Always_on_64bits -> best_msig decl
+ | Unknown -> worst_msig decl
+
+(** [msig_of_context ~decl_loc constructor context] returns the
+ separability signature of a single-constructor type whose
+ definition is valid in the mode context [context].
+
+ Note: A GADT constructor introduces existential type variables, and
+ may also introduce some equalities between its return type
+ parameters and type expressions containing universal and
+ existential variables. In other words, it introduces new type
+ variables in scope, and restricts existing variables by adding
+ equality constraints.
+
+ [msig_of_context] performs the reverse transformation: the context
+ [ctx] computed from the argument of the constructor mentions
+ existential variables, and the function returns a context over the
+ (universal) type parameters only. (Type constraints do not
+ introduce existential variables, but they do introduce equalities;
+ they are handled as GADTs equalities by this function.)
+
+ The transformation is separability-preserving in the following
+ sense: for any valid instance of the result mode signature
+ (replacing the universal type parameters with ground types
+ respecting the variable's separability mode), any possible
+ extension of this context instance with ground instances for the
+ existential variables of [parameter] that respects the equation
+ constraints will validate the separability requirements of the
+ modes in the input context [ctx].
+
+ Sometimes no such universal context exists, as an existential type
+ cannot be safely introduced, then this function raises an [Error]
+ exception with a [Non_separable_evar] payload. *)
+let msig_of_context : decl_loc:Location.t -> parameters:type_expr list
+ -> context -> Sep.signature =
+ fun ~decl_loc ~parameters context ->
+ let handle_equation (acc, context) param_instance =
+ (* In the theory, GADT equations are of the form
+ ('a = <ty>)
+ for each type parameter 'a of the type constructor. For each
+ such equation, we should "strengthen" the current context in
+ the following way:
+ - if <ty> is another variable 'b,
+ the mode of 'a is set to the mode of 'b,
+ and 'b is set to Ind
+ - if <ty> is a type expression whose variables are all Ind,
+ set 'a to Ind and discard the equation
+ - otherwise (one of the variable of 'b is not Ind),
+ set 'a to Deepsep and set all variables of <ty> to Ind
+
+ In practice, type parameters are determined by their position
+ in a list, they do not necessarily have a corresponding type variable.
+ Instead of "setting 'a" in the context as in the description above,
+ we build a list of modes by repeated consing into
+ an accumulator variable [acc], setting existential variables
+ to Ind as we go. *)
+ let param_instance = Ctype.repr param_instance in
+ let get context var =
+ try TVarMap.find var context with Not_found -> Ind in
+ let set_ind context var =
+ TVarMap.add var Ind context in
+ let is_ind context var = match get context var with
+ | Ind -> true
+ | Sep | Deepsep -> false in
+ match param_instance.desc with
+ | Tvar text ->
+ let var = {text; id = param_instance.Types.id} in
+ (get context var) :: acc, (set_ind context var)
+ | _ ->
+ let instance_exis = free_variables param_instance in
+ if List.for_all (is_ind context) instance_exis then
+ Ind :: acc, context
+ else
+ Deepsep :: acc, List.fold_left set_ind context instance_exis
+ in
+ let mode_signature, context =
+ let (mode_signature_rev, ctx) =
+ List.fold_left handle_equation ([], context) parameters in
+ (* Note: our inference system is not principal, because the
+ inference result depends on the order in which those
+ equations are processed. (To our knowledge this is the only
+ source of non-principality.) If two parameters ('a, 'b) are
+ forced to be equal to each other, and also separable, then
+ either modes (Sep, Ind) and (Ind, Sep) are correct, allow
+ more declarations than (Sep, Sep), but (Ind, Ind) would be
+ unsound.
+
+ Such a non-principal example is the following:
+
+ type ('a, 'b) almost_eq =
+ | Almost_refl : 'c -> ('c, 'c) almost_eq
+
+ (This example looks strange: GADT equations are typically
+ either on only one parameter, or on two parameters that are
+ not used to classify constructor arguments. Indeed, we have
+ not found non-principal declarations in real-world code.)
+
+ In a non-principal system, it is important the our choice of
+ non-unique solution be at least predictable. We find it more
+ natural, when either ('a : Sep, 'b : Ind) and ('a : Ind,
+ 'b : Sep) are correct because 'a = 'b, to choose to make the
+ first/leftmost parameter more constrained. We read this as
+ saying that 'a must be Sep, and 'b = 'a so 'b can be
+ Ind. (We define the second parameter as equal of the first,
+ already-seen parameter; instead of saying that the first
+ parameter is equal to the not-yet-seen second one.)
+
+ This is achieved by processing the equations from left to
+ right with List.fold_left, instead of using
+ List.fold_right. The code is slightly more awkward as it
+ needs a List.rev on the accumulated modes, but it gives
+ a more predictable/natural (non-principal) behavior.
+ *)
+ (List.rev mode_signature_rev, ctx) in
+ (* After all variables determined by the parameters have been set to Ind
+ by [handle_equation], all variables remaining in the context are
+ purely existential and should not require a stronger mode than Ind. *)
+ let check_existential evar mode =
+ if rank mode > rank Ind then
+ raise (Error (decl_loc, Non_separable_evar evar.text))
+ in
+ TVarMap.iter check_existential context;
+ mode_signature
+
+(** [check_def env def] returns the signature required
+ for the type definition [def] in the typing environment [env].
+
+ The exception [Error] is raised if we discover that
+ no such signature exists -- the definition will always be invalid.
+ This only happens when the definition is marked to be unboxed. *)
+
+let check_def
+ : Env.t -> type_definition -> Sep.signature
+ = fun env def ->
+ let boxed = not def.type_unboxed.unboxed in
+ match structure def with
+ | Abstract ->
+ assert boxed;
+ msig_of_external_type def
+ | Synonym type_expr ->
+ check_type env type_expr Sep
+ |> msig_of_context ~decl_loc:def.type_loc ~parameters:def.type_params
+ | Open | Algebraic (Zero | Several | One (Zero | Several)) ->
+ assert boxed;
+ best_msig def
+ | Algebraic (One (One constructor)) ->
+ if boxed then best_msig def
+ else
+ check_type env constructor.argument_type Sep
+ |> msig_of_context ~decl_loc:def.type_loc
+ ~parameters:constructor.result_type_parameter_instances
+
+let compute_decl env decl =
+ if Config.flat_float_array then check_def env decl
+ else
+ (* Hack: in -no-flat-float-array mode, instead of always returning
+ [best_msig], we first compute the separability signature --
+ falling back to [best_msig] if it fails.
+
+ This discipline is conservative: it never
+ rejects -no-flat-float-array programs. At the same time it
+ guarantees that, for any program that is also accepted
+ in -flat-float-array mode, the same separability will be
+ inferred in the two modes. In particular, the same .cmi files
+ and digests will be produced.
+
+ Before we introduced this hack, the production of different
+ .cmi files would break the build system of the compiler itself,
+ when trying to build a -no-flat-float-array system from
+ a bootstrap compiler itself using -flat-float-array. See #9291.
+ *)
+ try check_def env decl with
+ | Error _ ->
+ (* It could be nice to emit a warning here, so that users know
+ that their definition would be rejected in -flat-float-array mode *)
+ best_msig decl
+
+(** Separability as a generic property *)
+type prop = Types.Separability.signature
+
+let property : (prop, unit) Typedecl_properties.property =
+ let open Typedecl_properties in
+ let eq ts1 ts2 =
+ List.length ts1 = List.length ts2
+ && List.for_all2 Sep.eq ts1 ts2 in
+ let merge ~prop:_ ~new_prop =
+ (* the update function is monotonous: ~new_prop is always
+ more informative than ~prop, which can be ignored *)
+ new_prop in
+ let default decl = best_msig decl in
+ let compute env decl () = compute_decl env decl in
+ let update_decl decl type_separability = { decl with type_separability } in
+ let check _env _id _decl () = () in (* FIXME run final check? *)
+ { eq; merge; default; compute; update_decl; check; }
+
+(* Definition using the fixpoint infrastructure. *)
+let update_decls env decls =
+ Typedecl_properties.compute_property_noreq property env decls
--- /dev/null
+(**************************************************************************)
+(* *)
+(* OCaml *)
+(* *)
+(* Gabriel Scherer, projet Parsifal, INRIA Saclay *)
+(* Rodolphe Lepigre, projet Deducteam, INRIA Saclay *)
+(* *)
+(* Copyright 2018 Institut National de Recherche en Informatique et *)
+(* en Automatique. *)
+(* *)
+(* All rights reserved. This file is distributed under the terms of *)
+(* the GNU Lesser General Public License version 2.1, with the *)
+(* special exception on linking described in the file LICENSE. *)
+(* *)
+(**************************************************************************)
+
+(** The OCaml runtime assumes for type-directed optimizations that all types
+ are "separable". A type is "separable" if either all its inhabitants
+ (the values of this type) are floating-point numbers, or none of them are.
+
+ (Note: This assumption is required for the dynamic float array optimization;
+ it is only made if Config.flat_float_array is set,
+ otherwise the code in this module becomes trivial
+ -- see {!compute_decl}.)
+
+ This soundness requirement could be broken by type declarations mixing
+ existentials and the "[@@unboxed]" annotation. Consider the declaration
+
+ {[
+ type any = Any : 'a -> any [@@unboxed]
+ ]}
+
+ which corresponds to the existential type "exists a. a". If this type is
+ allowed to be unboxed, then it is inhabited by both [float] values
+ and non-[float] values. On the contrary, if unboxing is disallowed, the
+ inhabitants are all blocks with the [Any] constructors pointing to its
+ parameter: they may point to a float, but they are not floats.
+
+ The present module contains a static analysis ensuring that declarations
+ annotated with "[@@unboxed]" can be safely unboxed. The idea is to check
+ the "separability" (in the above sense) of the argument type that would
+ be unboxed, and reject the unboxed declaration if it would create a
+ non-separable type.
+
+ Checking mutually-recursive type declarations is a bit subtle.
+ Consider, for example, the following declarations.
+
+ {[
+ type foo = Foo : 'a t -> foo [@@unboxed]
+ and 'a t = ...
+ ]}
+
+ Deciding whether the type [foo] should be accepted requires inspecting
+ the declaration of ['a t], which may itself refer to [foo] in turn.
+ In general, the analysis performs a fixpoint computation. It is somewhat
+ similar to what is done for inferring the variance of type parameters.
+
+ Our analysis is defined using inference rules for our judgment
+ [Def; Gamma |- t : m], in which a type expression [t] is checked
+ against a "mode" [m]. This "mode" describes the separability
+ requirement on the type expression (see below for
+ more details). The mode [Gamma] maps type variables to modes and
+ [Def] records the "mode signature" of the mutually-recursive type
+ declarations that are being checked.
+
+ The "mode signature" of a type with parameters [('a, 'b) t] is of the
+ form [('a : m1, 'b : m2) t], where [m1] and [m2] are modes. Its meaning
+ is the following: a concrete instance [(foo, bar) t] of the type is
+ separable if [foo] has mode [m1] and [bar] has mode [m2]. *)
+
+type error =
+ | Non_separable_evar of string option
+exception Error of Location.t * error
+(** Exception raised when a type declaration is not separable, or when its
+ separability cannot be established. *)
+
+type mode = Types.Separability.t = Ind | Sep | Deepsep
+(** The mode [Sep] ("separable") characterizes types that are indeed separable:
+ either they only contain floating-point values, or none of the values
+ at this type are floating-point values.
+ On a type parameter, it indicates that this parameter must be
+ separable for the whole type definition to be separable. For
+ example, the mode signature for the type declaration [type 'a
+ t = 'a] is [('a : Sep) t]. For the right-hand side to be
+ separable, the parameter ['a] must be separable.
+
+ The mode [Ind] ("indifferent") characterizes any type -- separable
+ or not.
+ On a type parameter, it indicates that this parameter needs not be
+ separable for the whole type definition to be separable. For
+ example, [type 'a t = 'a * bool] does not require its parameter
+ ['a] to be separable as ['a * bool] can never contain [float]
+ values. Its mode signature is thus [('a : Ind) t].
+
+ Finally, the mode [Deepsep] ("deeply separable") characterizes
+ types that are separable, and whose type sub-expressions are also
+ separable. This advanced feature is only used in the presence of
+ constraints.
+ For example, [type 'a t = 'b constraint 'a = 'b * bool]
+ may not be separable even if ['a] is (its separately depends on 'b,
+ a fragment of 'a), so its mode signature is [('a : Deepsep) t].
+
+ The different modes are ordered as [Ind < Sep < Deepsep] (from the least
+ demanding to the most demanding). *)
+
+val compute_decl : Env.t -> Types.type_declaration -> mode list
+(** [compute_decl env def] returns the signature required
+ for the type definition [def] in the typing environment [env]
+ -- including signatures for the current recursive block.
+
+ The {!Error} exception is raised if no such signature exists
+ -- the definition will always be invalid. This only happens
+ when the definition is marked to be unboxed.
+
+ Variant (or record) declarations that are not marked with the
+ "[@@unboxed]" annotation, including those that contain several variants
+ (or labels), are always separable. In particular, their mode signatures
+ do not require anything of their type parameters, which are marked [Ind].
+
+ Finally, if {!Config.flat_float_array} is not set, then separability
+ is not required anymore; we just use [Ind] as the mode of each parameter
+ without any check.
+*)
+
+(** Property interface (see {!Typedecl_properties}). These functions
+ rely on {!compute_decl} and raise the {!Error} exception on error. *)
+type prop = Types.Separability.signature
+val property : (prop, unit) Typedecl_properties.property
+val update_decls :
+ Env.t ->
+ (Ident.t * Typedecl_properties.decl) list ->
+ (Ident.t * Typedecl_properties.decl) list
type attribute = Parsetree.attribute
type attributes = attribute list
-type pattern =
- { pat_desc: pattern_desc;
+type value = Value_pattern
+type computation = Computation_pattern
+
+type _ pattern_category =
+| Value : value pattern_category
+| Computation : computation pattern_category
+
+type pattern = value general_pattern
+and 'k general_pattern = 'k pattern_desc pattern_data
+
+and 'a pattern_data =
+ { pat_desc: 'a;
pat_loc: Location.t;
pat_extra : (pat_extra * Location.t * attribute list) list;
pat_type: type_expr;
- mutable pat_env: Env.t;
+ pat_env: Env.t;
pat_attributes: attribute list;
}
| Tpat_open of Path.t * Longident.t loc * Env.t
| Tpat_unpack
-and pattern_desc =
- Tpat_any
- | Tpat_var of Ident.t * string loc
- | Tpat_alias of pattern * Ident.t * string loc
- | Tpat_constant of constant
- | Tpat_tuple of pattern list
- | Tpat_construct of
- Longident.t loc * constructor_description * pattern list
- | Tpat_variant of label * pattern option * row_desc ref
- | Tpat_record of
- (Longident.t loc * label_description * pattern) list *
- closed_flag
- | Tpat_array of pattern list
- | Tpat_or of pattern * pattern * row_desc option
- | Tpat_lazy of pattern
- | Tpat_exception of pattern
+and 'k pattern_desc =
+ (* value patterns *)
+ | Tpat_any : value pattern_desc
+ | Tpat_var : Ident.t * string loc -> value pattern_desc
+ | Tpat_alias :
+ value general_pattern * Ident.t * string loc -> value pattern_desc
+ | Tpat_constant : constant -> value pattern_desc
+ | Tpat_tuple : value general_pattern list -> value pattern_desc
+ | Tpat_construct :
+ Longident.t loc * constructor_description * value general_pattern list ->
+ value pattern_desc
+ | Tpat_variant :
+ label * value general_pattern option * row_desc ref ->
+ value pattern_desc
+ | Tpat_record :
+ (Longident.t loc * label_description * value general_pattern) list *
+ closed_flag ->
+ value pattern_desc
+ | Tpat_array : value general_pattern list -> value pattern_desc
+ | Tpat_lazy : value general_pattern -> value pattern_desc
+ (* computation patterns *)
+ | Tpat_value : tpat_value_argument -> computation pattern_desc
+ | Tpat_exception : value general_pattern -> computation pattern_desc
+ (* generic constructions *)
+ | Tpat_or :
+ 'k general_pattern * 'k general_pattern * row_desc option ->
+ 'k pattern_desc
+
+and tpat_value_argument = value general_pattern
and expression =
{ exp_desc: expression_desc;
| Texp_constant of constant
| Texp_let of rec_flag * value_binding list * expression
| Texp_function of { arg_label : arg_label; param : Ident.t;
- cases : case list; partial : partial; }
+ cases : value case list; partial : partial; }
| Texp_apply of expression * (arg_label * expression option) list
- | Texp_match of expression * case list * partial
- | Texp_try of expression * case list
+ | Texp_match of expression * computation case list * partial
+ | Texp_try of expression * value case list
| Texp_tuple of expression list
| Texp_construct of
Longident.t loc * constructor_description * expression list
let_ : binding_op;
ands : binding_op list;
param : Ident.t;
- body : case;
+ body : value case;
partial : partial;
}
| Texp_unreachable
Tmeth_name of string
| Tmeth_val of Ident.t
-and case =
+and 'k case =
{
- c_lhs: pattern;
+ c_lhs: 'k general_pattern;
c_guard: expression option;
c_rhs: expression;
}
(* Auxiliary functions over the a.s.t. *)
-let shallow_iter_pattern_desc f = function
- | Tpat_alias(p, _, _) -> f p
- | Tpat_tuple patl -> List.iter f patl
- | Tpat_construct(_, _, patl) -> List.iter f patl
- | Tpat_variant(_, pat, _) -> Option.iter f pat
+let as_computation_pattern (p : pattern) : computation general_pattern =
+ {
+ pat_desc = Tpat_value p;
+ pat_loc = p.pat_loc;
+ pat_extra = [];
+ pat_type = p.pat_type;
+ pat_env = p.pat_env;
+ pat_attributes = [];
+ }
+
+let rec classify_pattern_desc : type k . k pattern_desc -> k pattern_category =
+ function
+ | Tpat_alias _ -> Value
+ | Tpat_tuple _ -> Value
+ | Tpat_construct _ -> Value
+ | Tpat_variant _ -> Value
+ | Tpat_record _ -> Value
+ | Tpat_array _ -> Value
+ | Tpat_lazy _ -> Value
+ | Tpat_any -> Value
+ | Tpat_var _ -> Value
+ | Tpat_constant _ -> Value
+
+ | Tpat_value _ -> Computation
+ | Tpat_exception _ -> Computation
+
+ | Tpat_or(p1, p2, _) ->
+ begin match classify_pattern p1, classify_pattern p2 with
+ | Value, Value -> Value
+ | Computation, Computation -> Computation
+ end
+
+and classify_pattern
+ : type k . k general_pattern -> k pattern_category
+ = fun pat ->
+ classify_pattern_desc pat.pat_desc
+
+type pattern_action =
+ { f : 'k . 'k general_pattern -> unit }
+let shallow_iter_pattern_desc
+ : type k . pattern_action -> k pattern_desc -> unit
+ = fun f -> function
+ | Tpat_alias(p, _, _) -> f.f p
+ | Tpat_tuple patl -> List.iter f.f patl
+ | Tpat_construct(_, _, patl) -> List.iter f.f patl
+ | Tpat_variant(_, pat, _) -> Option.iter f.f pat
| Tpat_record (lbl_pat_list, _) ->
- List.iter (fun (_, _, pat) -> f pat) lbl_pat_list
- | Tpat_array patl -> List.iter f patl
- | Tpat_or(p1, p2, _) -> f p1; f p2
- | Tpat_lazy p -> f p
- | Tpat_exception p -> f p
+ List.iter (fun (_, _, pat) -> f.f pat) lbl_pat_list
+ | Tpat_array patl -> List.iter f.f patl
+ | Tpat_lazy p -> f.f p
| Tpat_any
| Tpat_var _
| Tpat_constant _ -> ()
-
-let shallow_map_pattern_desc f d =
- match d with
+ | Tpat_value p -> f.f p
+ | Tpat_exception p -> f.f p
+ | Tpat_or(p1, p2, _) -> f.f p1; f.f p2
+
+type pattern_transformation =
+ { f : 'k . 'k general_pattern -> 'k general_pattern }
+let shallow_map_pattern_desc
+ : type k . pattern_transformation -> k pattern_desc -> k pattern_desc
+ = fun f d -> match d with
| Tpat_alias (p1, id, s) ->
- Tpat_alias (f p1, id, s)
+ Tpat_alias (f.f p1, id, s)
| Tpat_tuple pats ->
- Tpat_tuple (List.map f pats)
+ Tpat_tuple (List.map f.f pats)
| Tpat_record (lpats, closed) ->
- Tpat_record (List.map (fun (lid, l,p) -> lid, l, f p) lpats, closed)
+ Tpat_record (List.map (fun (lid, l,p) -> lid, l, f.f p) lpats, closed)
| Tpat_construct (lid, c,pats) ->
- Tpat_construct (lid, c, List.map f pats)
+ Tpat_construct (lid, c, List.map f.f pats)
| Tpat_array pats ->
- Tpat_array (List.map f pats)
- | Tpat_lazy p1 -> Tpat_lazy (f p1)
- | Tpat_exception p1 -> Tpat_exception (f p1)
+ Tpat_array (List.map f.f pats)
+ | Tpat_lazy p1 -> Tpat_lazy (f.f p1)
| Tpat_variant (x1, Some p1, x2) ->
- Tpat_variant (x1, Some (f p1), x2)
- | Tpat_or (p1,p2,path) ->
- Tpat_or (f p1, f p2, path)
+ Tpat_variant (x1, Some (f.f p1), x2)
| Tpat_var _
| Tpat_constant _
| Tpat_any
| Tpat_variant (_,None,_) -> d
-
-let rec iter_pattern f p =
- f p;
- shallow_iter_pattern_desc (iter_pattern f) p.pat_desc
-
-let exists_pattern f p =
+ | Tpat_value p -> Tpat_value (f.f p)
+ | Tpat_exception p -> Tpat_exception (f.f p)
+ | Tpat_or (p1,p2,path) ->
+ Tpat_or (f.f p1, f.f p2, path)
+
+let rec iter_general_pattern
+ : type k . pattern_action -> k general_pattern -> unit
+ = fun f p ->
+ f.f p;
+ shallow_iter_pattern_desc
+ { f = fun p -> iter_general_pattern f p }
+ p.pat_desc
+
+let iter_pattern (f : pattern -> unit) =
+ iter_general_pattern
+ { f = fun (type k) (p : k general_pattern) ->
+ match classify_pattern p with
+ | Value -> f p
+ | Computation -> () }
+
+let rec map_general_pattern
+ : type k . pattern_transformation -> k general_pattern -> k general_pattern
+ = fun f p ->
+ let pat_desc =
+ shallow_map_pattern_desc
+ { f = fun p -> map_general_pattern f p }
+ p.pat_desc in
+ f.f { p with pat_desc }
+
+type pattern_predicate = { f : 'k . 'k general_pattern -> bool }
+let exists_general_pattern (f : pattern_predicate) p =
let exception Found in
- let raiser f x = if (f x) then raise Found else () in
- match iter_pattern (raiser f) p with
+ match
+ iter_general_pattern
+ { f = fun p -> if f.f p then raise Found else () }
+ p
+ with
| exception Found -> true
| () -> false
+let exists_pattern (f : pattern -> bool) =
+ exists_general_pattern
+ { f = fun (type k) (p : k general_pattern) ->
+ match classify_pattern p with
+ | Value -> f p
+ | Computation -> false }
+
+
(* List the identifiers bound by a pattern or a let *)
-let rec iter_bound_idents f pat =
+let rec iter_bound_idents
+ : type k . _ -> k general_pattern -> _
+ = fun f pat ->
match pat.pat_desc with
| Tpat_var (id,s) ->
f (id,s,pat.pat_type)
(* Invariant : both arguments bind the same variables *)
iter_bound_idents f p1
| d ->
- shallow_iter_pattern_desc (iter_bound_idents f) d
+ shallow_iter_pattern_desc
+ { f = fun p -> iter_bound_idents f p }
+ d
let rev_pat_bound_idents_full pat =
let idents_full = ref [] in
let alpha_var env id = List.assoc id env
-let rec alpha_pat env p = match p.pat_desc with
-| Tpat_var (id, s) -> (* note the ``Not_found'' case *)
- {p with pat_desc =
- try Tpat_var (alpha_var env id, s) with
- | Not_found -> Tpat_any}
-| Tpat_alias (p1, id, s) ->
- let new_p = alpha_pat env p1 in
- begin try
- {p with pat_desc = Tpat_alias (new_p, alpha_var env id, s)}
- with
- | Not_found -> new_p
- end
-| d ->
- {p with pat_desc = shallow_map_pattern_desc (alpha_pat env) d}
+let rec alpha_pat
+ : type k . _ -> k general_pattern -> k general_pattern
+ = fun env p -> match p.pat_desc with
+ | Tpat_var (id, s) -> (* note the ``Not_found'' case *)
+ {p with pat_desc =
+ try Tpat_var (alpha_var env id, s) with
+ | Not_found -> Tpat_any}
+ | Tpat_alias (p1, id, s) ->
+ let new_p = alpha_pat env p1 in
+ begin try
+ {p with pat_desc = Tpat_alias (new_p, alpha_var env id, s)}
+ with
+ | Not_found -> new_p
+ end
+ | d ->
+ let pat_desc =
+ shallow_map_pattern_desc { f = fun p -> alpha_pat env p } d in
+ {p with pat_desc}
let mkloc = Location.mkloc
let mknoloc = Location.mknoloc
let split_pattern pat =
- let combine_pattern_desc_opts ~into p1 p2 =
+ let combine_opts merge p1 p2 =
match p1, p2 with
| None, None -> None
| Some p, None
| None, Some p ->
Some p
| Some p1, Some p2 ->
- (* The third parameter of [Tpat_or] is [Some _] only for "#typ"
- patterns, which we do *not* expand. Hence we can put [None] here. *)
- Some { into with pat_desc = Tpat_or (p1, p2, None) }
+ Some (merge p1 p2)
in
- let rec split_pattern pat =
- match pat.pat_desc with
- | Tpat_or (p1, p2, None) ->
- let vals1, exns1 = split_pattern p1 in
- let vals2, exns2 = split_pattern p2 in
- combine_pattern_desc_opts ~into:pat vals1 vals2,
- (* We could change the pattern type for exception patterns to
- [Predef.exn], but it doesn't really matter. *)
- combine_pattern_desc_opts ~into:pat exns1 exns2
+ let into pat p1 p2 =
+ (* The third parameter of [Tpat_or] is [Some _] only for "#typ"
+ patterns, which we do *not* expand. Hence we can put [None] here. *)
+ { pat with pat_desc = Tpat_or (p1, p2, None) } in
+ let rec split_pattern cpat =
+ match cpat.pat_desc with
+ | Tpat_value p ->
+ Some p, None
| Tpat_exception p ->
None, Some p
- | _ ->
- Some pat, None
+ | Tpat_or (cp1, cp2, _) ->
+ let vals1, exns1 = split_pattern cp1 in
+ let vals2, exns2 = split_pattern cp2 in
+ combine_opts (into cpat) vals1 vals2,
+ (* We could change the pattern type for exception patterns to
+ [Predef.exn], but it doesn't really matter. *)
+ combine_opts (into cpat) exns1 exns2
in
split_pattern pat
*)
open Asttypes
-open Types
(* Value expressions for the core language *)
(** {1 Core language} *)
-type pattern =
- { pat_desc: pattern_desc;
+type value = Value_pattern
+type computation = Computation_pattern
+
+type _ pattern_category =
+| Value : value pattern_category
+| Computation : computation pattern_category
+
+type pattern = value general_pattern
+and 'k general_pattern = 'k pattern_desc pattern_data
+
+and 'a pattern_data =
+ { pat_desc: 'a;
pat_loc: Location.t;
pat_extra : (pat_extra * Location.t * attributes) list;
- pat_type: type_expr;
- mutable pat_env: Env.t;
+ pat_type: Types.type_expr;
+ pat_env: Env.t;
pat_attributes: attributes;
}
; pat_extra = (Tpat_unpack, _, _) :: ... }
*)
-and pattern_desc =
- Tpat_any
+and 'k pattern_desc =
+ (* value patterns *)
+ | Tpat_any : value pattern_desc
(** _ *)
- | Tpat_var of Ident.t * string loc
+ | Tpat_var : Ident.t * string loc -> value pattern_desc
(** x *)
- | Tpat_alias of pattern * Ident.t * string loc
+ | Tpat_alias :
+ value general_pattern * Ident.t * string loc -> value pattern_desc
(** P as a *)
- | Tpat_constant of constant
+ | Tpat_constant : constant -> value pattern_desc
(** 1, 'a', "true", 1.0, 1l, 1L, 1n *)
- | Tpat_tuple of pattern list
+ | Tpat_tuple : value general_pattern list -> value pattern_desc
(** (P1, ..., Pn)
Invariant: n >= 2
*)
- | Tpat_construct of
- Longident.t loc * constructor_description * pattern list
+ | Tpat_construct :
+ Longident.t loc * Types.constructor_description *
+ value general_pattern list ->
+ value pattern_desc
(** C []
C P [P]
C (P1, ..., Pn) [P1; ...; Pn]
*)
- | Tpat_variant of label * pattern option * row_desc ref
+ | Tpat_variant :
+ label * value general_pattern option * Types.row_desc ref ->
+ value pattern_desc
(** `A (None)
`A P (Some P)
See {!Types.row_desc} for an explanation of the last parameter.
*)
- | Tpat_record of
- (Longident.t loc * label_description * pattern) list *
- closed_flag
+ | Tpat_record :
+ (Longident.t loc * Types.label_description * value general_pattern) list *
+ closed_flag ->
+ value pattern_desc
(** { l1=P1; ...; ln=Pn } (flag = Closed)
{ l1=P1; ...; ln=Pn; _} (flag = Open)
Invariant: n > 0
*)
- | Tpat_array of pattern list
+ | Tpat_array : value general_pattern list -> value pattern_desc
(** [| P1; ...; Pn |] *)
- | Tpat_or of pattern * pattern * row_desc option
+ | Tpat_lazy : value general_pattern -> value pattern_desc
+ (** lazy P *)
+ (* computation patterns *)
+ | Tpat_value : tpat_value_argument -> computation pattern_desc
+ (** P
+
+ Invariant: Tpat_value pattern should not carry
+ pat_attributes or pat_extra metadata coming from user
+ syntax, which must be on the inner pattern node -- to
+ facilitate searching for a certain value pattern
+ constructor with a specific attributed.
+
+ To enforce this restriction, we made the argument of
+ the Tpat_value constructor a private synonym of [pattern],
+ requiring you to use the [as_computation_pattern] function
+ below instead of using the [Tpat_value] constructor directly.
+ *)
+ | Tpat_exception : value general_pattern -> computation pattern_desc
+ (** exception P *)
+ (* generic constructions *)
+ | Tpat_or :
+ 'k general_pattern * 'k general_pattern * Types.row_desc option ->
+ 'k pattern_desc
(** P1 | P2
[row_desc] = [Some _] when translating [Ppat_type _],
[None] otherwise.
*)
- | Tpat_lazy of pattern
- (** lazy P *)
- | Tpat_exception of pattern
- (** exception P *)
+
+and tpat_value_argument = private value general_pattern
and expression =
{ exp_desc: expression_desc;
exp_loc: Location.t;
exp_extra: (exp_extra * Location.t * attributes) list;
- exp_type: type_expr;
+ exp_type: Types.type_expr;
exp_env: Env.t;
exp_attributes: attributes;
}
let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)
*)
| Texp_function of { arg_label : arg_label; param : Ident.t;
- cases : case list; partial : partial; }
+ cases : value case list; partial : partial; }
(** [Pexp_fun] and [Pexp_function] both translate to [Texp_function].
See {!Parsetree} for more details.
(Labelled "y", Some (Texp_constant Const_int 3))
])
*)
- | Texp_match of expression * case list * partial
+ | Texp_match of expression * computation case list * partial
(** match E0 with
| P1 -> E1
| P2 | exception P3 -> E2
[Texp_match (E0, [(P1, E1); (P2 | exception P3, E2);
(exception P4, E3)], _)]
*)
- | Texp_try of expression * case list
+ | Texp_try of expression * value case list
(** try E with P1 -> E1 | ... | PN -> EN *)
| Texp_tuple of expression list
(** (E1, ..., EN) *)
| Texp_construct of
- Longident.t loc * constructor_description * expression list
+ Longident.t loc * Types.constructor_description * expression list
(** C []
C E [E]
C (E1, ..., En) [E1;...;En]
{ fields = [| l1, Kept t1; l2 Override P2 |]; representation;
extended_expression = Some E0 }
*)
- | Texp_field of expression * Longident.t loc * label_description
+ | Texp_field of expression * Longident.t loc * Types.label_description
| Texp_setfield of
- expression * Longident.t loc * label_description * expression
+ expression * Longident.t loc * Types.label_description * expression
| Texp_array of expression list
| Texp_ifthenelse of expression * expression * expression option
| Texp_sequence of expression * expression
let_ : binding_op;
ands : binding_op list;
param : Ident.t;
- body : case;
+ body : value case;
partial : partial;
}
| Texp_unreachable
Tmeth_name of string
| Tmeth_val of Ident.t
-and case =
+and 'k case =
{
- c_lhs: pattern;
+ c_lhs: 'k general_pattern;
c_guard: expression option;
c_rhs: expression;
}
| Tcl_let of rec_flag * value_binding list *
(Ident.t * expression) list * class_expr
| Tcl_constraint of
- class_expr * class_type option * string list * string list * Concr.t
+ class_expr * class_type option * string list * string list * Types.Concr.t
(* Visible instance variables, methods and concrete methods *)
| Tcl_open of open_description * class_expr
cstr_self: pattern;
cstr_fields: class_field list;
cstr_type: Types.class_signature;
- cstr_meths: Ident.t Meths.t;
+ cstr_meths: Ident.t Types.Meths.t;
}
and class_field =
{
mb_id: Ident.t option;
mb_name: string option loc;
- mb_presence: module_presence;
+ mb_presence: Types.module_presence;
mb_expr: module_expr;
mb_attributes: attributes;
mb_loc: Location.t;
and primitive_coercion =
{
pc_desc: Primitive.description;
- pc_type: type_expr;
+ pc_type: Types.type_expr;
pc_env: Env.t;
pc_loc : Location.t;
}
{
md_id: Ident.t option;
md_name: string option loc;
- md_presence: module_presence;
+ md_presence: Types.module_presence;
md_type: module_type;
md_attributes: attributes;
md_loc: Location.t;
and core_type =
{ mutable ctyp_desc : core_type_desc;
(** mutable because of [Typeclass.declare_method] *)
- mutable ctyp_type : type_expr;
+ mutable ctyp_type : Types.type_expr;
(** mutable because of [Typeclass.declare_method] *)
ctyp_env : Env.t; (* BINANNOT ADDED *)
ctyp_loc : Location.t;
(* Auxiliary functions over the a.s.t. *)
+(** [as_computation_pattern p] is a computation pattern with description
+ [Tpat_value p], which enforces a correct placement of pat_attributes
+ and pat_extra metadata (on the inner value pattern, rather than on
+ the computation pattern). *)
+val as_computation_pattern: pattern -> computation general_pattern
+
+val classify_pattern_desc: 'k pattern_desc -> 'k pattern_category
+val classify_pattern: 'k general_pattern -> 'k pattern_category
+
+type pattern_action =
+ { f : 'k . 'k general_pattern -> unit }
val shallow_iter_pattern_desc:
- (pattern -> unit) -> pattern_desc -> unit
+ pattern_action -> 'k pattern_desc -> unit
+
+type pattern_transformation =
+ { f : 'k . 'k general_pattern -> 'k general_pattern }
val shallow_map_pattern_desc:
- (pattern -> pattern) -> pattern_desc -> pattern_desc
+ pattern_transformation -> 'k pattern_desc -> 'k pattern_desc
+val iter_general_pattern: pattern_action -> 'k general_pattern -> unit
val iter_pattern: (pattern -> unit) -> pattern -> unit
+
+type pattern_predicate = { f : 'k . 'k general_pattern -> bool }
+val exists_general_pattern: pattern_predicate -> 'k general_pattern -> bool
val exists_pattern: (pattern -> bool) -> pattern -> bool
+(** bottom-up mapping of patterns: the transformation function is
+ called on the children before being called on the parent *)
+val map_general_pattern:
+ pattern_transformation -> 'k general_pattern -> 'k general_pattern
+
val let_bound_idents: value_binding list -> Ident.t list
val let_bound_idents_full:
- value_binding list -> (Ident.t * string loc * type_expr) list
+ value_binding list -> (Ident.t * string loc * Types.type_expr) list
(** Alpha conversion of patterns *)
-val alpha_pat: (Ident.t * Ident.t) list -> pattern -> pattern
+val alpha_pat:
+ (Ident.t * Ident.t) list -> 'k general_pattern -> 'k general_pattern
val mknoloc: 'a -> 'a Asttypes.loc
val mkloc: 'a -> Location.t -> 'a Asttypes.loc
-val pat_bound_idents: pattern -> Ident.t list
+val pat_bound_idents: 'k general_pattern -> Ident.t list
val pat_bound_idents_full:
- pattern -> (Ident.t * string loc * type_expr) list
+ 'k general_pattern -> (Ident.t * string loc * Types.type_expr) list
(** Splits an or pattern into its value (left) and exception (right) parts. *)
-val split_pattern : pattern -> pattern option * pattern option
+val split_pattern:
+ computation general_pattern -> pattern option * pattern option
let type_open_ ?used_slot ?toplevel ovf env loc lid =
let path = Env.lookup_module_path ~load:true ~loc:lid.loc lid.txt env in
match Env.open_signature ~loc ?used_slot ?toplevel ovf path env with
- | Some env -> path, env
- | None ->
+ | Ok env -> path, env
+ | Error _ ->
let md = Env.find_module path env in
ignore (extract_sig_open env lid.loc md.md_type);
assert false
in
let open_module env m =
let open Asttypes in
- let lid = {loc; txt = Longident.parse m } in
- snd (type_open_ Override env lid.loc lid)
+ let lexbuf = Lexing.from_string m in
+ let txt =
+ Location.init lexbuf (Printf.sprintf "command line argument: -open %S" m);
+ Parse.simple_module_path lexbuf in
+ snd (type_open_ Override env loc {txt;loc})
in
let add_units env units =
String.Set.fold
in
(od, newenv)
-(* Record a module type *)
-let rm node =
- Stypes.record (Stypes.Ti_mod node);
- node
-
(* Forward declaration, to be filled in by type_module_type_of *)
let type_module_type_of_fwd :
(Env.t -> Parsetree.module_expr ->
| Some id -> Env.add_type ~check:false id newdecl env
in
let env = if rs = Trec_not then env else add_rec_types env rem in
- Includemod.type_declarations ~loc env id newdecl decl;
+ Includemod.type_declarations ~mark:Mark_both ~loc env id newdecl decl;
Typedecl.check_coherence env loc (Path.Pident id) newdecl
let update_rec_next rs rem =
| Pwith_typesubst _ | Pwith_modsubst _ -> true
in
let real_ids = ref [] in
- let rec merge env sg namelist row_id =
+ let rec merge sig_env sg namelist row_id =
match (sg, namelist, constr) with
([], _, _) ->
- raise(Error(loc, env, With_no_component lid.txt))
+ raise(Error(loc, sig_env, With_no_component lid.txt))
| (Sig_type(id, decl, rs, priv) :: rem, [s],
Pwith_type (_, ({ptype_kind = Ptype_abstract} as sdecl)))
when Ident.name id = s && Typedecl.is_fixed_type sdecl ->
let decl_row =
- { type_params =
+ let arity = List.length sdecl.ptype_params in
+ {
+ type_params =
List.map (fun _ -> Btype.newgenvar()) sdecl.ptype_params;
- type_arity = List.length sdecl.ptype_params;
+ type_arity = arity;
type_kind = Type_abstract;
type_private = Private;
type_manifest = None;
make_variance (not n) (not c) false
)
sdecl.ptype_params;
+ type_separability =
+ Types.Separability.default_signature ~arity;
type_loc = sdecl.ptype_loc;
type_is_newtype = false;
type_expansion_scope = Btype.lowest_level;
type_attributes = [];
type_immediate = Unknown;
type_unboxed = unboxed_false_default_false;
+ type_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
}
and id_row = Ident.create_local (s^"#row") in
let initial_env =
Env.add_type ~check:false id_row decl_row initial_env
in
- let tdecl = Typedecl.transl_with_constraint
- initial_env id (Some(Pident id_row)) decl sdecl in
+ let tdecl =
+ Typedecl.transl_with_constraint id (Some(Pident id_row))
+ ~sig_env ~sig_decl:decl ~outer_env:initial_env sdecl in
let newdecl = tdecl.typ_type in
- check_type_decl env sdecl.ptype_loc id row_id newdecl decl rs rem;
+ check_type_decl sig_env sdecl.ptype_loc id row_id newdecl decl rs rem;
let decl_row = {decl_row with type_params = newdecl.type_params} in
let rs' = if rs = Trec_first then Trec_not else rs in
(Pident id, lid, Twith_type tdecl),
Sig_type(id_row, decl_row, rs', priv)
:: Sig_type(id, newdecl, rs, priv)
:: rem
- | (Sig_type(id, decl, rs, priv) :: rem , [s], Pwith_type (_, sdecl))
+ | (Sig_type(id, sig_decl, rs, priv) :: rem , [s],
+ (Pwith_type (_, sdecl) | Pwith_typesubst (_, sdecl) as constr))
when Ident.name id = s ->
let tdecl =
- Typedecl.transl_with_constraint initial_env id None decl sdecl in
- let newdecl = tdecl.typ_type in
- check_type_decl env sdecl.ptype_loc id row_id newdecl decl rs rem;
- (Pident id, lid, Twith_type tdecl),
- Sig_type(id, newdecl, rs, priv) :: rem
+ Typedecl.transl_with_constraint id None
+ ~sig_env ~sig_decl ~outer_env:initial_env sdecl in
+ let newdecl = tdecl.typ_type and loc = sdecl.ptype_loc in
+ check_type_decl sig_env loc id row_id newdecl sig_decl rs rem;
+ begin match constr with
+ Pwith_type _ ->
+ (Pident id, lid, Twith_type tdecl),
+ Sig_type(id, newdecl, rs, priv) :: rem
+ | (* Pwith_typesubst *) _ ->
+ real_ids := [Pident id];
+ (Pident id, lid, Twith_typesubst tdecl),
+ update_rec_next rs rem
+ end
| (Sig_type(id, _, _, _) :: rem, [s], (Pwith_type _ | Pwith_typesubst _))
when Ident.name id = s ^ "#row" ->
- merge env rem namelist (Some id)
- | (Sig_type(id, decl, rs, _priv) :: rem, [s], Pwith_typesubst (_, sdecl))
- when Ident.name id = s ->
- (* Check as for a normal with constraint, but discard definition *)
- let tdecl =
- Typedecl.transl_with_constraint initial_env id None decl sdecl in
- let newdecl = tdecl.typ_type in
- check_type_decl env sdecl.ptype_loc id row_id newdecl decl rs rem;
- real_ids := [Pident id];
- (Pident id, lid, Twith_typesubst tdecl),
- update_rec_next rs rem
+ merge sig_env rem namelist (Some id)
| (Sig_module(id, pres, md, rs, priv) :: rem, [s], Pwith_module (_, lid'))
when Ident.name id = s ->
let path, md' = Env.lookup_module ~loc lid'.txt initial_env in
let mty = md'.md_type in
- let mty = Mtype.scrape_for_type_of ~remove_aliases env mty in
+ let mty = Mtype.scrape_for_type_of ~remove_aliases sig_env mty in
let md'' = { md' with md_type = mty } in
- let newmd = Mtype.strengthen_decl ~aliasable:false env md'' path in
- ignore(Includemod.modtypes ~loc env newmd.md_type md.md_type);
+ let newmd = Mtype.strengthen_decl ~aliasable:false sig_env md'' path in
+ ignore(Includemod.modtypes ~mark:Mark_both ~loc sig_env
+ newmd.md_type md.md_type);
(Pident id, lid, Twith_module (path, lid')),
Sig_module(id, pres, newmd, rs, priv) :: rem
| (Sig_module(id, _, md, rs, _) :: rem, [s], Pwith_modsubst (_, lid'))
when Ident.name id = s ->
let path, md' = Env.lookup_module ~loc lid'.txt initial_env in
- let aliasable = not (Env.is_functor_arg path env) in
- let newmd = Mtype.strengthen_decl ~aliasable env md' path in
- ignore(Includemod.modtypes ~loc env newmd.md_type md.md_type);
+ let aliasable = not (Env.is_functor_arg path sig_env) in
+ ignore
+ (Includemod.strengthened_module_decl ~loc ~mark:Mark_both
+ ~aliasable sig_env md' path md);
real_ids := [Pident id];
(Pident id, lid, Twith_modsubst (path, lid')),
update_rec_next rs rem
- | (Sig_module(id, _, ({md_type = Mty_alias _} as md), _, _) as item :: rem,
- s :: namelist, (Pwith_module _ | Pwith_type _))
+ | (Sig_module(id, _, md, rs, priv) as item :: rem, s :: namelist, constr)
when Ident.name id = s ->
- let ((path, _, tcstr), _) =
- merge env (extract_sig env loc md.md_type) namelist None
- in
+ let sg = extract_sig sig_env loc md.md_type in
+ let ((path, _, tcstr), newsg) = merge_signature sig_env sg namelist in
let path = path_concat id path in
real_ids := path :: !real_ids;
- (path, lid, tcstr), item :: rem
- | (Sig_module(id, _, md, rs, priv) :: rem, s :: namelist, _)
- when Ident.name id = s ->
- let ((path, _path_loc, tcstr), newsg) =
- merge env (extract_sig env loc md.md_type) namelist None
+ let item =
+ match md.md_type, constr with
+ Mty_alias _, (Pwith_module _ | Pwith_type _) ->
+ (* A module alias cannot be refined, so keep it
+ and just check that the constraint is correct *)
+ item
+ | _ ->
+ let newmd = {md with md_type = Mty_signature newsg} in
+ Sig_module(id, Mp_present, newmd, rs, priv)
in
- let path = path_concat id path in
- real_ids := path :: !real_ids;
- let newmd = {md with md_type=Mty_signature newsg} in
- let item = Sig_module(id, Mp_present, newmd, rs, priv) in
(path, lid, tcstr),
item :: rem
| (item :: rem, _, _) ->
- let (cstr, items) = merge (Env.add_item item env) rem namelist row_id
+ let (cstr, items) = merge sig_env rem namelist row_id
in
cstr, item :: items
+ and merge_signature env sg namelist =
+ let sig_env = Env.add_signature sg env in
+ merge sig_env sg namelist None
in
try
let names = Longident.flatten lid.txt in
- let (tcstr, sg) = merge initial_env sg names None in
+ let (tcstr, sg) = merge_signature initial_env sg names in
if destructive_substitution then (
match List.rev !real_ids with
| [] -> assert false
Types.md_type = approx_modtype env pmd.pmd_type;
md_attributes = pmd.pmd_attributes;
md_loc = pmd.pmd_loc;
+ md_uid = Uid.internal_not_actually_unique;
}
and approx_sig env ssg =
mtd_type = Option.map (approx_modtype env) sinfo.pmtd_type;
mtd_attributes = sinfo.pmtd_attributes;
mtd_loc = sinfo.pmtd_loc;
+ mtd_uid = Uid.internal_not_actually_unique;
}
let approx_modtype env smty =
{ md_type = arg.mty_type;
md_attributes = [];
md_loc = param.loc;
+ md_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
}
in
Env.enter_module_declaration ~scope ~arg:true name Mp_present
td.typ_private = Private
then
raise (Error (td.typ_loc, env, Invalid_type_subst_rhs));
+ let params = td.typ_type.type_params in
+ if params_are_constrained params
+ then raise(Error(loc, env, With_cannot_remove_constrained_type));
let info =
let subst =
Subst.add_type_function (Pident td.typ_id)
- ~params:td.typ_type.type_params
+ ~params
~body:(Option.get td.typ_type.type_manifest)
Subst.identity
in
md_type=tmty.mty_type;
md_attributes=pmd.pmd_attributes;
md_loc=pmd.pmd_loc;
+ md_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
}
in
let id, newenv =
else
{ md_type = Mty_alias path;
md_attributes = pms.pms_attributes;
- md_loc = pms.pms_loc }
+ md_loc = pms.pms_loc;
+ md_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
+ }
in
let pres =
match md.md_type with
let (tdecls, newenv) =
transl_recmodule_modtypes env sdecls in
let decls =
- List.filter_map (fun md ->
+ List.filter_map (fun (md, uid) ->
match md.md_id with
| None -> None
- | Some id -> Some (id, md)
+ | Some id -> Some (id, md, uid)
) tdecls
in
- List.iter
- (fun (id, md) -> Signature_names.check_module names md.md_loc id)
- decls;
+ List.iter (fun (id, md, _) ->
+ Signature_names.check_module names md.md_loc id
+ ) decls;
let (trem, rem, final_env) = transl_sig newenv srem in
- mksig (Tsig_recmodule tdecls) env loc :: trem,
- map_rec (fun rs (id, md) ->
+ mksig (Tsig_recmodule (List.map fst tdecls)) env loc :: trem,
+ map_rec (fun rs (id, md, uid) ->
let d = {Types.md_type = md.md_type.mty_type;
md_attributes = md.md_attributes;
md_loc = md.md_loc;
+ md_uid = uid;
} in
Sig_module(id, Mp_present, d, rs, Exported))
decls rem,
Types.mtd_type=Option.map (fun t -> t.mty_type) tmty;
mtd_attributes=pmtd_attributes;
mtd_loc=pmtd_loc;
+ mtd_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
}
in
let scope = Ctype.create_scope () in
and transl_recmodule_modtypes env sdecls =
let make_env curr =
List.fold_left
- (fun env (id, _, mty) ->
- Option.fold ~none:env
- ~some:(fun id -> Env.add_module ~arg:true id Mp_present mty env) id)
- env curr in
- let make_env2 curr =
- List.fold_left
- (fun env (id, _, mty) ->
+ (fun env (id, _, md, _) ->
Option.fold ~none:env
- ~some:(fun id ->
- Env.add_module ~arg:true id Mp_present mty.mty_type env
- ) id)
+ ~some:(fun id -> Env.add_module_declaration ~check:true ~arg:true
+ id Mp_present md env) id)
env curr in
let transition env_c curr =
List.map2
- (fun pmd (id, id_loc, _mty) ->
+ (fun pmd (id, id_loc, md, _) ->
let tmty =
Builtin_attributes.warning_scope pmd.pmd_attributes
(fun () -> transl_modtype env_c pmd.pmd_type)
in
- (id, id_loc, tmty))
+ let md = { md with Types.md_type = tmty.mty_type } in
+ (id, id_loc, md, tmty))
sdecls curr in
- let map_mtys =
+ let map_mtys curr =
List.filter_map
- (fun (id, _, mty) ->
- Option.map (fun id ->
- (id, Types.{md_type = mty.mty_type;
- md_loc = mty.mty_loc;
- md_attributes = mty.mty_attributes})
- ) id)
+ (fun (id, _, md, _) -> Option.map (fun id -> (id, md)) id)
+ curr
in
let scope = Ctype.create_scope () in
let ids =
let init =
List.map2
(fun id pmd ->
- (id, pmd.pmd_name, approx_modtype approx_env pmd.pmd_type))
+ let md =
+ { md_type = approx_modtype approx_env pmd.pmd_type;
+ md_loc = pmd.pmd_loc;
+ md_attributes = pmd.pmd_attributes;
+ md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) }
+ in
+ (id, pmd.pmd_name, md, ()))
ids sdecls
in
let env0 = make_env init in
Warnings.without_warnings
(fun () -> transition env0 init)
in
- let env1 = make_env2 dcl1 in
+ let env1 = make_env dcl1 in
check_recmod_typedecls env1 (map_mtys dcl1);
let dcl2 = transition env1 dcl1 in
(*
Format.printf "%a: %a@." Printtyp.ident id Printtyp.modtype mty)
dcl2;
*)
- let env2 = make_env2 dcl2 in
+ let env2 = make_env dcl2 in
check_recmod_typedecls env2 (map_mtys dcl2);
let dcl2 =
- List.map2
- (fun pmd (id, id_loc, mty) ->
+ List.map2 (fun pmd (id, id_loc, md, mty) ->
+ let tmd =
{md_id=id; md_name=id_loc; md_type=mty;
md_presence=Mp_present;
md_loc=pmd.pmd_loc;
- md_attributes=pmd.pmd_attributes})
- sdecls dcl2
+ md_attributes=pmd.pmd_attributes}
+ in
+ tmd, md.md_uid
+ ) sdecls dcl2
in
(dcl2, env2)
(* Generate fresh names Y_i for the rec. bound module idents X_i *)
let bindings1 =
List.map
- (fun (id, _name, _mty_decl, _modl, mty_actual, _attrs, _loc) ->
+ (fun (id, _name, _mty_decl, _modl, mty_actual, _attrs, _loc, _uid) ->
let ids =
Option.map
(fun id -> (id, Ident.create_scoped ~scope (Ident.name id))) id
end else begin
(* Base case: check inclusion of s(mty_actual) in s(mty_decl)
and insert coercion if needed *)
- let check_inclusion (id, name, mty_decl, modl, mty_actual, attrs, loc) =
+ let check_inclusion
+ (id, name, mty_decl, modl, mty_actual, attrs, loc, uid) =
let mty_decl' = Subst.modtype (Rescope scope) s mty_decl.mty_type
and mty_actual' = subst_and_strengthen env scope s id mty_actual in
let coercion =
try
- Includemod.modtypes ~loc:modl.mod_loc env mty_actual' mty_decl'
+ Includemod.modtypes ~loc:modl.mod_loc ~mark:Mark_both env
+ mty_actual' mty_decl'
with Includemod.Error msg ->
raise(Error(modl.mod_loc, env, Not_included msg)) in
let modl' =
mod_loc = modl.mod_loc;
mod_attributes = [];
} in
- {
- mb_id = id;
- mb_name = name;
- mb_presence = Mp_present;
- mb_expr = modl';
- mb_attributes = attrs;
- mb_loc = loc;
- }
+ let mb =
+ {
+ mb_id = id;
+ mb_name = name;
+ mb_presence = Mp_present;
+ mb_expr = modl';
+ mb_attributes = attrs;
+ mb_loc = loc;
+ }
+ in
+ mb, uid
in
List.map check_inclusion bindings
end
| Some mty when nl <> [] ->
package_constraints env loc mty
(List.combine (List.map Longident.flatten nl) tl)
- | _ ->
+ | _ | exception Not_found (* missing cmi *) ->
if nl = [] then Mty_ident p
else raise(Error(loc, env, Signature_expected))
- | exception Not_found -> assert false
let package_subtype env p1 nl1 tl1 p2 nl2 tl2 =
let mkmty p nl tl =
modtype_of_package env Location.none p nl tl
in
let mty1 = mkmty p1 nl1 tl1 and mty2 = mkmty p2 nl2 tl2 in
- try Includemod.modtypes ~loc:Location.none env mty1 mty2 = Tcoerce_none
- with Includemod.Error _msg -> false
- (* raise(Error(Location.none, env, Not_included msg)) *)
+ let loc = Location.none in
+ match Includemod.modtypes ~loc ~mark:Mark_both env mty1 mty2 with
+ | Tcoerce_none -> true
+ | _ | exception Includemod.Error _ -> false
let () = Ctype.package_subtype := package_subtype
else mty
in
{ md with mod_type = mty }
- in rm md
+ in md
| Pmod_structure sstr ->
let (str, sg, names, _finalenv) =
type_structure funct_body anchor env sstr smod.pmod_loc in
let md =
- rm { mod_desc = Tmod_structure str;
- mod_type = Mty_signature sg;
- mod_env = env;
- mod_attributes = smod.pmod_attributes;
- mod_loc = smod.pmod_loc }
+ { mod_desc = Tmod_structure str;
+ mod_type = Mty_signature sg;
+ mod_env = env;
+ mod_attributes = smod.pmod_attributes;
+ mod_loc = smod.pmod_loc }
in
let sg' = Signature_names.simplify _finalenv names sg in
if List.length sg' = List.length sg then md else
{ md_type = mty.mty_type;
md_attributes = [];
md_loc = param.loc;
+ md_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
}
in
let id, newenv =
Named (id, param, mty), Types.Named (id, mty.mty_type), newenv, true
in
let body = type_module sttn funct_body None newenv sbody in
- rm { mod_desc = Tmod_functor(t_arg, body);
- mod_type = Mty_functor(ty_arg, body.mod_type);
- mod_env = env;
- mod_attributes = smod.pmod_attributes;
- mod_loc = smod.pmod_loc }
+ { mod_desc = Tmod_functor(t_arg, body);
+ mod_type = Mty_functor(ty_arg, body.mod_type);
+ mod_env = env;
+ mod_attributes = smod.pmod_attributes;
+ mod_loc = smod.pmod_loc }
| Pmod_apply(sfunct, sarg) ->
let arg = type_module true funct_body None env sarg in
let path = path_of_module arg in
raise (Error (sfunct.pmod_loc, env, Apply_generative));
if funct_body && Mtype.contains_type env funct.mod_type then
raise (Error (smod.pmod_loc, env, Not_allowed_in_functor_body));
- rm { mod_desc = Tmod_apply(funct, arg, Tcoerce_none);
- mod_type = mty_res;
- mod_env = env;
- mod_attributes = smod.pmod_attributes;
- mod_loc = smod.pmod_loc }
+ { mod_desc = Tmod_apply(funct, arg, Tcoerce_none);
+ mod_type = mty_res;
+ mod_env = env;
+ mod_attributes = smod.pmod_attributes;
+ mod_loc = smod.pmod_loc }
| Mty_functor (Named (param, mty_param), mty_res) as mty_functor ->
let coercion =
try
- Includemod.modtypes ~loc:sarg.pmod_loc env arg.mod_type mty_param
+ Includemod.modtypes ~loc:sarg.pmod_loc ~mark:Mark_both env
+ arg.mod_type mty_param
with Includemod.Error msg ->
raise(Error(sarg.pmod_loc, env, Not_included msg)) in
let mty_appl =
Cannot_eliminate_dependency mty_functor))
in
begin match
- Includemod.modtypes ~loc:smod.pmod_loc env mty_res nondep_mty
+ Includemod.modtypes ~mark:Mark_neither
+ ~loc:smod.pmod_loc env mty_res nondep_mty
with
| Tcoerce_none -> ()
| _ ->
in
check_well_formed_module env smod.pmod_loc
"the signature of this functor application" mty_appl;
- rm { mod_desc = Tmod_apply(funct, arg, coercion);
- mod_type = mty_appl;
- mod_env = env;
- mod_attributes = smod.pmod_attributes;
- mod_loc = smod.pmod_loc }
+ { mod_desc = Tmod_apply(funct, arg, coercion);
+ mod_type = mty_appl;
+ mod_env = env;
+ mod_attributes = smod.pmod_attributes;
+ mod_loc = smod.pmod_loc }
| Mty_alias path ->
raise(Error(sfunct.pmod_loc, env, Cannot_scrape_alias path))
| _ ->
let md =
wrap_constraint env true arg mty.mty_type (Tmodtype_explicit mty)
in
- rm { md with
- mod_loc = smod.pmod_loc;
- mod_attributes = smod.pmod_attributes;
- }
+ { md with
+ mod_loc = smod.pmod_loc;
+ mod_attributes = smod.pmod_attributes;
+ }
| Pmod_unpack sexp ->
if !Clflags.principal then Ctype.begin_def ();
in
if funct_body && Mtype.contains_type env mty then
raise (Error (smod.pmod_loc, env, Not_allowed_in_functor_body));
- rm { mod_desc = Tmod_unpack(exp, mty);
- mod_type = mty;
- mod_env = env;
- mod_attributes = smod.pmod_attributes;
- mod_loc = smod.pmod_loc }
+ { mod_desc = Tmod_unpack(exp, mty);
+ mod_type = mty;
+ mod_env = env;
+ mod_attributes = smod.pmod_attributes;
+ mod_loc = smod.pmod_loc }
| Pmod_extension ext ->
raise (Error_forward (Builtin_attributes.error_of_extension ext))
Env.enter_signature ~scope (extract_sig_open env md.mod_loc md.mod_type)
env
in
- List.iter (Signature_names.check_sig_item ~info:`From_open names loc) sg;
+ let info, visibility =
+ match toplevel with
+ | Some false | None -> Some `From_open, Hidden
+ | Some true -> None, Exported
+ in
+ List.iter (Signature_names.check_sig_item ?info names loc) sg;
let sg =
List.map (function
- | Sig_value(id, vd, _) -> Sig_value(id, vd, Hidden)
- | Sig_type(id, td, rs, _) -> Sig_type(id, td, rs, Hidden)
- | Sig_typext(id, ec, et, _) -> Sig_typext(id, ec, et, Hidden)
- | Sig_module(id, mp, md, rs, _) -> Sig_module(id, mp, md, rs, Hidden)
- | Sig_modtype(id, mtd, _) -> Sig_modtype(id, mtd, Hidden)
- | Sig_class(id, cd, rs, _) -> Sig_class(id, cd, rs, Hidden)
- | Sig_class_type(id, ctd, rs, _) -> Sig_class_type(id, ctd, rs, Hidden)
+ | Sig_value(id, vd, _) -> Sig_value(id, vd, visibility)
+ | Sig_type(id, td, rs, _) -> Sig_type(id, td, rs, visibility)
+ | Sig_typext(id, ec, et, _) -> Sig_typext(id, ec, et, visibility)
+ | Sig_module(id, mp, md, rs, _) ->
+ Sig_module(id, mp, md, rs, visibility)
+ | Sig_modtype(id, mtd, _) -> Sig_modtype(id, mtd, visibility)
+ | Sig_class(id, cd, rs, _) -> Sig_class(id, cd, rs, visibility)
+ | Sig_class_type(id, ctd, rs, _) ->
+ Sig_class_type(id, ctd, rs, visibility)
) sg
in
let open_descr = {
| Mty_alias _ -> Mp_absent
| _ -> Mp_present
in
+ let md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) in
let md =
{ md_type = enrich_module_type anchor name.txt modl.mod_type env;
md_attributes = attrs;
md_loc = pmb_loc;
+ md_uid;
}
in
(*prerr_endline (Ident.unique_toplevel_name id);*)
{md_type = modl.mod_type;
md_attributes = attrs;
md_loc = pmb_loc;
+ md_uid;
}, Trec_not, Exported)]
in
Tstr_module {mb_id=id; mb_name=name; mb_expr=modl;
pmd_attributes=attrs; pmd_loc=loc}) sbind
) in
List.iter
- (fun md ->
+ (fun (md, _) ->
Option.iter Signature_names.(check_module names md.md_loc) md.md_id)
decls;
let bindings1 =
List.map2
- (fun {md_id=id; md_type=mty} (name, _, smodl, attrs, loc) ->
+ (fun ({md_id=id; md_type=mty}, uid) (name, _, smodl, attrs, loc) ->
let modl =
Builtin_attributes.warning_scope attrs
(fun () ->
let mty' =
enrich_module_type anchor name.txt modl.mod_type newenv
in
- (id, name, mty, modl, mty', attrs, loc))
+ (id, name, mty, modl, mty', attrs, loc, uid))
decls sbind in
let newenv = (* allow aliasing recursive modules from outside *)
List.fold_left
- (fun env md ->
+ (fun env (md, uid) ->
match md.md_id with
| None -> env
| Some id ->
md_type = md.md_type.mty_type;
md_attributes = md.md_attributes;
md_loc = md.md_loc;
+ md_uid = uid;
}
in
Env.add_module_declaration ~check:true
let bindings2 =
check_recmodule_inclusion newenv bindings1 in
let mbs =
- List.filter_map (fun mb -> Option.map (fun id -> id, mb) mb.mb_id)
- bindings2
+ List.filter_map (fun (mb, uid) ->
+ Option.map (fun id -> id, mb, uid) mb.mb_id
+ ) bindings2
in
- Tstr_recmodule bindings2,
- map_rec (fun rs (id, mb) ->
+ Tstr_recmodule (List.map fst bindings2),
+ map_rec (fun rs (id, mb, uid) ->
Sig_module(id, Mp_present, {
md_type=mb.mb_expr.mod_type;
md_attributes=mb.mb_attributes;
md_loc=mb.mb_loc;
+ md_uid = uid;
}, rs, Exported))
mbs [],
newenv
let (str_rem, sig_rem, final_env) = type_struct new_env srem in
(str :: str_rem, sg @ sig_rem, final_env)
in
- if !Clflags.annotations then
- (* moved to genannot *)
- List.iter (function {pstr_loc = l} -> Stypes.record_phrase l) sstr;
let previous_saved_types = Cmt_format.get_saved_types () in
let run () =
let (items, sg, final_env) = type_struct env sstr in
match smod.pmod_desc with
| Pmod_ident lid -> (* turn off strengthening in this case *)
let path, md = Env.lookup_module ~loc:smod.pmod_loc lid.txt env in
- rm { mod_desc = Tmod_ident (path, lid);
- mod_type = md.md_type;
- mod_env = env;
- mod_attributes = smod.pmod_attributes;
- mod_loc = smod.pmod_loc }
+ { mod_desc = Tmod_ident (path, lid);
+ mod_type = md.md_type;
+ mod_env = env;
+ mod_attributes = smod.pmod_attributes;
+ mod_loc = smod.pmod_loc }
| _ -> type_module env smod
in
let mty = Mtype.scrape_for_type_of ~remove_aliases env tmty.mod_type in
(* Typecheck an implementation file *)
+let gen_annot outputprefix sourcefile annots =
+ Cmt2annot.gen_annot (Some (outputprefix ^ ".annot"))
+ ~sourcefile:(Some sourcefile) ~use_summaries:false annots
+
let type_implementation sourcefile outputprefix modulename initial_env ast =
Cmt_format.clear ();
Misc.try_finally (fun () ->
(fun () -> fprintf std_formatter "%a@."
(Printtyp.printed_signature sourcefile) simple_sg
);
+ gen_annot outputprefix sourcefile (Cmt_format.Implementation str);
(str, Tcoerce_none) (* result is ignored by Compile.implementation *)
end else begin
let sourceintf =
Interface_not_compiled sourceintf)) in
let dclsig = Env.read_signature modulename intf_file in
let coercion =
- Includemod.compunit initial_env ~mark:Includemod.Mark_positive
+ Includemod.compunit initial_env ~mark:Mark_positive
sourcefile sg intf_file dclsig
in
Typecore.force_delayed_checks ();
(* It is important to run these checks after the inclusion test above,
so that value declarations which are not used internally but
exported are not reported as being unused. *)
+ let annots = Cmt_format.Implementation str in
Cmt_format.save_cmt (outputprefix ^ ".cmt") modulename
- (Cmt_format.Implementation str) (Some sourcefile) initial_env None;
+ annots (Some sourcefile) initial_env None;
+ gen_annot outputprefix sourcefile annots;
(str, coercion)
end else begin
let coercion =
- Includemod.compunit initial_env ~mark:Includemod.Mark_positive
+ Includemod.compunit initial_env ~mark:Mark_positive
sourcefile sg "(inferred signature)" simple_sg
in
check_nongen_schemes finalenv simple_sg;
Env.save_signature ~alerts
simple_sg modulename (outputprefix ^ ".cmi")
in
+ let annots = Cmt_format.Implementation str in
Cmt_format.save_cmt (outputprefix ^ ".cmt") modulename
- (Cmt_format.Implementation str)
- (Some sourcefile) initial_env (Some cmi);
+ annots (Some sourcefile) initial_env (Some cmi);
+ gen_annot outputprefix sourcefile annots
end;
(str, coercion)
end
end
)
~exceptionally:(fun () ->
+ let annots =
+ Cmt_format.Partial_implementation
+ (Array.of_list (Cmt_format.get_saved_types ()))
+ in
Cmt_format.save_cmt (outputprefix ^ ".cmt") modulename
- (Cmt_format.Partial_implementation
- (Array.of_list (Cmt_format.get_saved_types ())))
- (Some sourcefile) initial_env None)
+ annots (Some sourcefile) initial_env None;
+ gen_annot outputprefix sourcefile annots
+ )
let save_signature modname tsg outputprefix source_file initial_env cmi =
Cmt_format.save_cmt (outputprefix ^ ".cmti") modname
let md =
{ md_type=Mty_signature sg;
md_attributes=[];
- md_loc=Location.none; }
+ md_loc=Location.none;
+ md_uid = Uid.mk ~current_unit:(Env.get_unit_name ());
+ }
in
Sig_module(newid, Mp_present, md, Trec_not, Exported))
units_with_ids
let dclsig = Env.read_signature modulename cmifile in
Cmt_format.save_cmt (prefix ^ ".cmt") modulename
(Cmt_format.Packed (sg, objfiles)) None initial_env None ;
- Includemod.compunit initial_env "(obtained by packing)" sg mlifile dclsig
+ Includemod.compunit initial_env ~mark:Mark_both
+ "(obtained by packing)" sg mlifile dclsig
end else begin
(* Determine imports *)
let unit_names = List.map fst units in
let equal t1 t2 = t1 == t2
end
+(* *)
+
+module Uid = struct
+ type t =
+ | Compilation_unit of string
+ | Item of { comp_unit: string; id: int }
+ | Internal
+ | Predef of string
+
+ include Identifiable.Make(struct
+ type nonrec t = t
+
+ let equal (x : t) y = x = y
+ let compare (x : t) y = compare x y
+ let hash (x : t) = Hashtbl.hash x
+
+ let print fmt = function
+ | Internal -> Format.pp_print_string fmt "<internal>"
+ | Predef name -> Format.fprintf fmt "<predef:%s>" name
+ | Compilation_unit s -> Format.pp_print_string fmt s
+ | Item { comp_unit; id } -> Format.fprintf fmt "%s.%d" comp_unit id
+
+ let output oc t =
+ let fmt = Format.formatter_of_out_channel oc in
+ print fmt t
+ end)
+
+ let id = ref (-1)
+
+ let reinit () = id := (-1)
+
+ let mk ~current_unit =
+ incr id;
+ Item { comp_unit = current_unit; id = !id }
+
+ let of_compilation_unit_id id =
+ if not (Ident.persistent id) then
+ Misc.fatal_errorf "Types.Uid.of_compilation_unit_id %S" (Ident.name id);
+ Compilation_unit (Ident.name id)
+
+ let of_predef_id id =
+ if not (Ident.is_predef id) then
+ Misc.fatal_errorf "Types.Uid.of_predef_id %S" (Ident.name id);
+ Predef (Ident.name id)
+
+ let internal_not_actually_unique = Internal
+
+ let for_actual_declaration = function
+ | Item _ -> true
+ | _ -> false
+end
+
(* Maps of methods and instance variables *)
module Meths = Misc.Stdlib.String.Map
val_kind: value_kind;
val_loc: Location.t;
val_attributes: Parsetree.attributes;
- }
+ val_uid: Uid.t;
+ }
and value_kind =
Val_reg (* Regular value *)
let get_lower v = (mem Pos v, mem Neg v, mem Inv v, mem Inj v)
end
+module Separability = struct
+ type t = Ind | Sep | Deepsep
+ type signature = t list
+ let eq (m1 : t) m2 = (m1 = m2)
+ let rank = function
+ | Ind -> 0
+ | Sep -> 1
+ | Deepsep -> 2
+ let compare m1 m2 = compare (rank m1) (rank m2)
+ let max m1 m2 = if rank m1 >= rank m2 then m1 else m2
+
+ let print ppf = function
+ | Ind -> Format.fprintf ppf "Ind"
+ | Sep -> Format.fprintf ppf "Sep"
+ | Deepsep -> Format.fprintf ppf "Deepsep"
+
+ let print_signature ppf modes =
+ let pp_sep ppf () = Format.fprintf ppf ",@," in
+ Format.fprintf ppf "@[(%a)@]"
+ (Format.pp_print_list ~pp_sep print) modes
+
+ let default_signature ~arity =
+ let default_mode = if Config.flat_float_array then Deepsep else Ind in
+ List.init arity (fun _ -> default_mode)
+end
+
(* Type definitions *)
type type_declaration =
type_private: private_flag;
type_manifest: type_expr option;
type_variance: Variance.t list;
+ type_separability: Separability.t list;
type_is_newtype: bool;
type_expansion_scope: int;
type_loc: Location.t;
type_attributes: Parsetree.attributes;
type_immediate: Type_immediacy.t;
type_unboxed: unboxed_status;
+ type_uid: Uid.t;
}
and type_kind =
ld_type: type_expr;
ld_loc: Location.t;
ld_attributes: Parsetree.attributes;
+ ld_uid: Uid.t;
}
and constructor_declaration =
cd_res: type_expr option;
cd_loc: Location.t;
cd_attributes: Parsetree.attributes;
+ cd_uid: Uid.t;
}
and constructor_arguments =
let unboxed_true_default_true = {unboxed = true; default = true}
type extension_constructor =
- { ext_type_path: Path.t;
- ext_type_params: type_expr list;
- ext_args: constructor_arguments;
- ext_ret_type: type_expr option;
- ext_private: private_flag;
- ext_loc: Location.t;
- ext_attributes: Parsetree.attributes; }
+ { ext_type_path: Path.t;
+ ext_type_params: type_expr list;
+ ext_args: constructor_arguments;
+ ext_ret_type: type_expr option;
+ ext_private: private_flag;
+ ext_loc: Location.t;
+ ext_attributes: Parsetree.attributes;
+ ext_uid: Uid.t;
+ }
and type_transparence =
Type_public (* unrestricted expansion *)
cty_variance: Variance.t list;
cty_loc: Location.t;
cty_attributes: Parsetree.attributes;
+ cty_uid: Uid.t;
}
type class_type_declaration =
clty_variance: Variance.t list;
clty_loc: Location.t;
clty_attributes: Parsetree.attributes;
+ clty_uid: Uid.t;
}
(* Type expressions for the module language *)
md_type: module_type;
md_attributes: Parsetree.attributes;
md_loc: Location.t;
+ md_uid: Uid.t;
}
and modtype_declaration =
mtd_type: module_type option; (* Note: abstract *)
mtd_attributes: Parsetree.attributes;
mtd_loc: Location.t;
+ mtd_uid: Uid.t;
}
and rec_status =
cstr_loc: Location.t;
cstr_attributes: Parsetree.attributes;
cstr_inlined: type_declaration option;
+ cstr_uid: Uid.t;
}
and constructor_tag =
lbl_private: private_flag; (* Read-only field? *)
lbl_loc: Location.t;
lbl_attributes: Parsetree.attributes;
+ lbl_uid: Uid.t;
}
let rec bound_value_identifiers = function
val hash : t -> int
end
+(* *)
+
+module Uid : sig
+ type t
+
+ val reinit : unit -> unit
+
+ val mk : current_unit:string -> t
+ val of_compilation_unit_id : Ident.t -> t
+ val of_predef_id : Ident.t -> t
+ val internal_not_actually_unique : t
+
+ val for_actual_declaration : t -> bool
+
+ include Identifiable.S with type t := t
+end
+
(* Maps of methods and instance variables *)
module Meths : Map.S with type key = string
val_kind: value_kind;
val_loc: Location.t;
val_attributes: Parsetree.attributes;
- }
+ val_uid: Uid.t;
+ }
and value_kind =
Val_reg (* Regular value *)
val get_lower : t -> bool * bool * bool * bool (* pos, neg, inv, inj *)
end
+module Separability : sig
+ (** see {!Typedecl_separability} for an explanation of separability
+ and separability modes.*)
+
+ type t = Ind | Sep | Deepsep
+ val eq : t -> t -> bool
+ val print : Format.formatter -> t -> unit
+
+ val rank : t -> int
+ (** Modes are ordered from the least to the most demanding:
+ Ind < Sep < Deepsep.
+ 'rank' maps them to integers in an order-respecting way:
+ m1 < m2 <=> rank m1 < rank m2 *)
+
+ val compare : t -> t -> int
+ (** Compare two mode according to their mode ordering. *)
+
+ val max : t -> t -> t
+ (** [max_mode m1 m2] returns the most demanding mode. It is used to
+ express the conjunction of two parameter mode constraints. *)
+
+ type signature = t list
+ (** The 'separability signature' of a type assigns a mode for
+ each of its parameters. [('a, 'b) t] has mode [(m1, m2)] if
+ [(t1, t2) t] is separable whenever [t1, t2] have mode [m1, m2]. *)
+
+ val print_signature : Format.formatter -> signature -> unit
+
+ val default_signature : arity:int -> signature
+ (** The most pessimistic separability for a completely unknown type. *)
+end
+
(* Type definitions *)
type type_declaration =
type_manifest: type_expr option;
type_variance: Variance.t list;
(* covariant, contravariant, weakly contravariant, injective *)
+ type_separability: Separability.t list;
type_is_newtype: bool;
type_expansion_scope: int;
type_loc: Location.t;
type_attributes: Parsetree.attributes;
type_immediate: Type_immediacy.t;
type_unboxed: unboxed_status;
+ type_uid: Uid.t;
}
and type_kind =
ld_type: type_expr;
ld_loc: Location.t;
ld_attributes: Parsetree.attributes;
+ ld_uid: Uid.t;
}
and constructor_declaration =
cd_res: type_expr option;
cd_loc: Location.t;
cd_attributes: Parsetree.attributes;
+ cd_uid: Uid.t;
}
and constructor_arguments =
val unboxed_true_default_true : unboxed_status
type extension_constructor =
- {
- ext_type_path: Path.t;
- ext_type_params: type_expr list;
- ext_args: constructor_arguments;
- ext_ret_type: type_expr option;
- ext_private: private_flag;
- ext_loc: Location.t;
- ext_attributes: Parsetree.attributes;
- }
+ {
+ ext_type_path: Path.t;
+ ext_type_params: type_expr list;
+ ext_args: constructor_arguments;
+ ext_ret_type: type_expr option;
+ ext_private: private_flag;
+ ext_loc: Location.t;
+ ext_attributes: Parsetree.attributes;
+ ext_uid: Uid.t;
+ }
and type_transparence =
Type_public (* unrestricted expansion *)
cty_variance: Variance.t list;
cty_loc: Location.t;
cty_attributes: Parsetree.attributes;
+ cty_uid: Uid.t;
}
type class_type_declaration =
clty_variance: Variance.t list;
clty_loc: Location.t;
clty_attributes: Parsetree.attributes;
+ clty_uid: Uid.t;
}
(* Type expressions for the module language *)
md_type: module_type;
md_attributes: Parsetree.attributes;
md_loc: Location.t;
+ md_uid: Uid.t;
}
and modtype_declaration =
mtd_type: module_type option; (* None: abstract *)
mtd_attributes: Parsetree.attributes;
mtd_loc: Location.t;
+ mtd_uid: Uid.t;
}
and rec_status =
cstr_loc: Location.t;
cstr_attributes: Parsetree.attributes;
cstr_inlined: type_declaration option;
+ cstr_uid: Uid.t;
}
and constructor_tag =
lbl_private: private_flag; (* Read-only field? *)
lbl_loc: Location.t;
lbl_attributes: Parsetree.attributes;
+ lbl_uid: Uid.t;
}
(** Extracts the list of "value" identifiers bound by a signature.
attribute: mapper -> T.attribute -> attribute;
attributes: mapper -> T.attribute list -> attribute list;
binding_op: mapper -> T.binding_op -> T.pattern -> binding_op;
- case: mapper -> T.case -> case;
- cases: mapper -> T.case list -> case list;
+ case: 'k . mapper -> 'k T.case -> case;
class_declaration: mapper -> T.class_declaration -> class_declaration;
class_description: mapper -> T.class_description -> class_description;
class_expr: mapper -> T.class_expr -> class_expr;
package_type: mapper -> T.package_type -> package_type;
open_declaration: mapper -> T.open_declaration -> open_declaration;
open_description: mapper -> T.open_description -> open_description;
- pat: mapper -> T.pattern -> pattern;
+ pat: 'k . mapper -> 'k T.general_pattern -> pattern;
row_field: mapper -> T.row_field -> row_field;
object_field: mapper -> T.object_field -> object_field;
signature: mapper -> T.signature -> signature;
let constant = function
| Const_char c -> Pconst_char c
- | Const_string (s,d) -> Pconst_string (s,d)
+ | Const_string (s,loc,d) -> Pconst_string (s,loc,d)
| Const_int i -> Pconst_integer (Int.to_string i, None)
| Const_int32 i -> Pconst_integer (Int32.to_string i, Some 'l')
| Const_int64 i -> Pconst_integer (Int64.to_string i, Some 'L')
| Text_rebind (_p, lid) -> Pext_rebind (map_loc sub lid)
)
-let pattern sub pat =
+let pattern : type k . _ -> k T.general_pattern -> _ = fun sub pat ->
let loc = sub.location sub pat.pat_loc in
(* todo: fix attributes on extras *)
let attrs = sub.attributes sub pat.pat_attributes in
Ppat_record (List.map (fun (lid, _, pat) ->
map_loc sub lid, sub.pat sub pat) list, closed)
| Tpat_array list -> Ppat_array (List.map (sub.pat sub) list)
- | Tpat_or (p1, p2, _) -> Ppat_or (sub.pat sub p1, sub.pat sub p2)
| Tpat_lazy p -> Ppat_lazy (sub.pat sub p)
+
| Tpat_exception p -> Ppat_exception (sub.pat sub p)
+ | Tpat_value p -> (sub.pat sub (p :> pattern)).ppat_desc
+ | Tpat_or (p1, p2, _) -> Ppat_or (sub.pat sub p1, sub.pat sub p2)
in
Pat.mk ~loc ~attrs desc
in
Exp.mk ~loc ~attrs desc
-let cases sub l = List.map (sub.case sub) l
-
-let case sub {c_lhs; c_guard; c_rhs} =
+let case : type k . mapper -> k case -> _ = fun sub {c_lhs; c_guard; c_rhs} ->
{
pc_lhs = sub.pat sub c_lhs;
pc_guard = Option.map (sub.expr sub) c_guard;
Pexp_fun (arg_label, None, sub.pat sub p, sub.expr sub e)
(* No label: it's a function. *)
| Texp_function { arg_label = Nolabel; cases; _; } ->
- Pexp_function (sub.cases sub cases)
+ Pexp_function (List.map (sub.case sub) cases)
(* Mix of both, we generate `fun ~label:$name$ -> match $name$ with ...` *)
| Texp_function { arg_label = Labelled s | Optional s as label; cases;
_ } ->
let name = fresh_name s exp.exp_env in
Pexp_fun (label, None, Pat.var ~loc {loc;txt = name },
Exp.match_ ~loc (Exp.ident ~loc {loc;txt= Lident name})
- (sub.cases sub cases))
+ (List.map (sub.case sub) cases))
| Texp_apply (exp, list) ->
Pexp_apply (sub.expr sub exp,
List.fold_right (fun (label, expo) list ->
| Some exp -> (label, sub.expr sub exp) :: list
) list [])
| Texp_match (exp, cases, _) ->
- Pexp_match (sub.expr sub exp, sub.cases sub cases)
+ Pexp_match (sub.expr sub exp, List.map (sub.case sub) cases)
| Texp_try (exp, cases) ->
- Pexp_try (sub.expr sub exp, sub.cases sub cases)
+ Pexp_try (sub.expr sub exp, List.map (sub.case sub) cases)
| Texp_tuple list ->
Pexp_tuple (List.map (sub.expr sub) list)
| Texp_construct (lid, _, args) ->
value_binding = value_binding;
constructor_declaration = constructor_declaration;
label_declaration = label_declaration;
- cases = cases;
case = case;
location = location;
row_field = row_field ;
type mapper = {
attribute: mapper -> Typedtree.attribute -> attribute;
attributes: mapper -> Typedtree.attribute list -> attribute list;
- binding_op: mapper -> Typedtree.binding_op -> Typedtree.pattern
- -> binding_op;
- case: mapper -> Typedtree.case -> case;
- cases: mapper -> Typedtree.case list -> case list;
+ binding_op:
+ mapper ->
+ Typedtree.binding_op -> Typedtree.pattern -> binding_op;
+ case: 'k . mapper -> 'k Typedtree.case -> case;
class_declaration: mapper -> Typedtree.class_declaration -> class_declaration;
class_description: mapper -> Typedtree.class_description -> class_description;
class_expr: mapper -> Typedtree.class_expr -> class_expr;
package_type: mapper -> Typedtree.package_type -> package_type;
open_declaration: mapper -> Typedtree.open_declaration -> open_declaration;
open_description: mapper -> Typedtree.open_description -> open_description;
- pat: mapper -> Typedtree.pattern -> pattern;
+ pat: 'k . mapper -> 'k Typedtree.general_pattern -> pattern;
row_field: mapper -> Typedtree.row_field -> row_field;
object_field: mapper -> Typedtree.object_field -> object_field;
signature: mapper -> Typedtree.signature -> signature;
tools to test the new release, and if you update *after* that you risk
breaking them again without them noticing.
-For example, the magic numbers for 4.07 were updated in
- 7c416d1c01f82122b767cd6f08ca7d0839fd15fa
-and
- c10b2edccc9704fd99673812f688c103e2ffcfcf
-
-(There are two commits as one kind of magic number was forgotten,
-ideally there should be only one commit.)
+For example, the magic numbers for 4.10 were updated in
+ 6423e5c9d11cfac1c07208aec9f761f37c1640f0
let run_command cmdline = ignore(command cmdline)
-(* Build @responsefile to work around Windows limitations on
- command-line length *)
+(* Build @responsefile to work around OS limitations on
+ command-line length.
+ Under Windows, the max length is 8187 minus the length of the
+ COMSPEC variable (or 7 if it's not set). To be on the safe side,
+ we'll use a response file if we need to pass 4096 or more bytes of
+ arguments.
+ For Unix-like systems, the threshold is 2^16 (64 KiB), which is
+ within the lowest observed limits (2^17 per argument under Linux;
+ between 70000 and 80000 for macOS).
+*)
+
let build_diversion lst =
let (responsefile, oc) = Filename.open_temp_file "camlresp" "" in
List.iter (fun f -> Printf.fprintf oc "%s\n" f) lst;
let lst = List.filter (fun f -> f <> "") lst in
let quoted = List.map Filename.quote lst in
let s = String.concat " " quoted in
- if String.length s >= 4096 && Sys.os_type = "Win32"
+ if String.length s >= 65536
+ || (String.length s >= 4096 && Sys.os_type = "Win32")
then build_diversion quoted
else s
(match !Clflags.c_compiler with
| Some cc -> cc
| None ->
- let (cflags, cppflags) =
- if !Clflags.native_code
- then (Config.ocamlopt_cflags, Config.ocamlopt_cppflags)
- else (Config.ocamlc_cflags, Config.ocamlc_cppflags) in
- (String.concat " " [Config.c_compiler; cflags; cppflags]))
+ (* #7678: ocamlopt only calls the C compiler to process .c files
+ from the command line, and the behaviour between
+ ocamlc/ocamlopt should be identical. *)
+ (String.concat " " [Config.c_compiler;
+ Config.ocamlc_cflags;
+ Config.ocamlc_cppflags]))
debug_prefix_map
(match output with
| None -> ""
(quote_files files)
extra
in
- command cmd = 0
+ command cmd
)
| MainDll
| Partial
-val call_linker: link_mode -> string -> string list -> string -> bool
+val call_linker: link_mode -> string -> string list -> string -> int
and error_size = ref 500 (* -error-size *)
and float_const_prop = ref true (* -no-float-const-prop *)
and transparent_modules = ref false (* -trans-mod *)
-let unique_ids = ref true
+let unique_ids = ref true (* -d(no-)unique-ds *)
+let locations = ref true (* -d(no-)locations *)
let dump_source = ref false (* -dsource *)
let dump_parsetree = ref false (* -dparsetree *)
and dump_typedtree = ref false (* -dtypedtree *)
- the manpages in man/ocaml{c,opt}.m
- the manual manual/manual/cmds/unified-options.etex
*)
- type t = Parsing | Typing
+ type t = Parsing | Typing | Scheduling
let to_string = function
| Parsing -> "parsing"
| Typing -> "typing"
+ | Scheduling -> "scheduling"
let of_string = function
| "parsing" -> Some Parsing
| "typing" -> Some Typing
+ | "scheduling" -> Some Scheduling
| _ -> None
let rank = function
| Parsing -> 0
| Typing -> 1
+ | Scheduling -> 50
let passes = [
Parsing;
Typing;
+ Scheduling;
]
- let pass_names = List.map to_string passes
+ let is_compilation_pass _ = true
+ let is_native_only = function
+ | Scheduling -> true
+ | _ -> false
+
+ let enabled is_native t = not (is_native_only t) || is_native
+
+ let available_pass_names ~native =
+ passes
+ |> List.filter (enabled native)
+ |> List.map to_string
end
let stop_after = ref None (* -stop-after *)
let should_stop_after pass =
- match !stop_after with
- | None -> false
- | Some stop -> Compiler_pass.rank stop <= Compiler_pass.rank pass
+ if Compiler_pass.(rank Typing <= rank pass) && !print_types then true
+ else
+ match !stop_after with
+ | None -> false
+ | Some stop -> Compiler_pass.rank stop <= Compiler_pass.rank pass
module String = Misc.Stdlib.String
val float_const_prop : bool ref
val transparent_modules : bool ref
val unique_ids : bool ref
+val locations : bool ref
val dump_source : bool ref
val dump_parsetree : bool ref
val dump_typedtree : bool ref
val insn_sched_default : bool
module Compiler_pass : sig
- type t = Parsing | Typing
+ type t = Parsing | Typing | Scheduling
val of_string : string -> t option
val to_string : t -> string
- val passes : t list
- val pass_names : string list
+ val is_compilation_pass : t -> bool
+ val available_pass_names : native:bool -> string list
end
val stop_after : Compiler_pass.t option ref
val should_stop_after : Compiler_pass.t -> bool
(** The flags ocamlc should pass to the C preprocessor *)
val ocamlopt_cflags : string
-(** The flags ocamlopt should pass to the C compiler *)
+ [@@ocaml.deprecated "Use ocamlc_cflags instead."]
+(** @deprecated {!ocamlc_cflags} should be used instead.
+ The flags ocamlopt should pass to the C compiler *)
val ocamlopt_cppflags : string
-(** The flags ocamlopt should pass to the C preprocessor *)
+ [@@ocaml.deprecated "Use ocamlc_cppflags instead."]
+(** @deprecated {!ocamlc_cppflags} should be used instead.
+ The flags ocamlopt should pass to the C preprocessor *)
val bytecomp_c_libraries: string
(** The C libraries to link with custom runtimes *)
let as_has_debug_prefix_map = %%AS_HAS_DEBUG_PREFIX_MAP%%
let ocamlc_cflags = "%%OCAMLC_CFLAGS%%"
let ocamlc_cppflags = "%%OCAMLC_CPPFLAGS%%"
-let ocamlopt_cflags = "%%OCAMLOPT_CFLAGS%%"
+(* #7678: ocamlopt uses these only to compile .c files, and the behaviour for
+ the two drivers should be identical. *)
+let ocamlopt_cflags = "%%OCAMLC_CFLAGS%%"
let ocamlopt_cppflags = "%%OCAMLOPT_CPPFLAGS%%"
let bytecomp_c_libraries = "%%BYTECCLIBS%%"
(* bytecomp_c_compiler and native_c_compiler have been supported for a
let function_sections = %%FUNCTION_SECTIONS%%
let afl_instrument = %%AFL_INSTRUMENT%%
-let exec_magic_number = "Caml1999X027"
+let exec_magic_number = "Caml1999X028"
(* exec_magic_number is duplicated in runtime/caml/exec.h *)
-and cmi_magic_number = "Caml1999I027"
-and cmo_magic_number = "Caml1999O027"
-and cma_magic_number = "Caml1999A027"
+and cmi_magic_number = "Caml1999I028"
+and cmo_magic_number = "Caml1999O028"
+and cma_magic_number = "Caml1999A028"
and cmx_magic_number =
if flambda then
- "Caml1999y027"
+ "Caml1999y028"
else
- "Caml1999Y027"
+ "Caml1999Y028"
and cmxa_magic_number =
if flambda then
- "Caml1999z027"
+ "Caml1999z028"
else
- "Caml1999Z027"
-and ast_impl_magic_number = "Caml1999M027"
-and ast_intf_magic_number = "Caml1999N027"
-and cmxs_magic_number = "Caml1999D027"
-and cmt_magic_number = "Caml1999T027"
+ "Caml1999Z028"
+and ast_impl_magic_number = "Caml1999M028"
+and ast_intf_magic_number = "Caml1999N028"
+and cmxs_magic_number = "Caml1999D028"
+and cmt_magic_number = "Caml1999T028"
let interface_suffix = ref ".mli"
let clear = Module_name.Tbl.clear
- exception Inconsistency of Module_name.t * filepath * filepath
+ exception Inconsistency of {
+ unit_name : Module_name.t;
+ inconsistent_source : string;
+ original_source : string;
+ }
exception Not_available of Module_name.t
+ let check_ tbl name crc source =
+ let (old_crc, old_source) = Module_name.Tbl.find tbl name in
+ if crc <> old_crc then raise(Inconsistency {
+ unit_name = name;
+ inconsistent_source = source;
+ original_source = old_source;
+ })
+
let check tbl name crc source =
- try
- let (old_crc, old_source) = Module_name.Tbl.find tbl name in
- if crc <> old_crc then raise(Inconsistency(name, source, old_source))
+ try check_ tbl name crc source
with Not_found ->
Module_name.Tbl.add tbl name (crc, source)
let check_noadd tbl name crc source =
- try
- let (old_crc, old_source) = Module_name.Tbl.find tbl name in
- if crc <> old_crc then raise(Inconsistency(name, source, old_source))
+ try check_ tbl name crc source
with Not_found ->
raise (Not_available name)
(* [filter pred tbl] removes from [tbl] table all (name, CRC) pairs
such that [pred name] is [false]. *)
- exception Inconsistency of Module_name.t * filepath * filepath
- (* Raised by [check] when a CRC mismatch is detected.
- First string is the name of the compilation unit.
- Second string is the source that caused the inconsistency.
- Third string is the source that set the CRC. *)
+ exception Inconsistency of {
+ unit_name : Module_name.t;
+ inconsistent_source : string;
+ original_source : string;
+ }
+ (* Raised by [check] when a CRC mismatch is detected. *)
exception Not_available of Module_name.t
(* Raised by [check_noadd] when a name doesn't have an associated
with type key = T.t
and type 'a t = 'a Map.Make (T).t
- val filter_map : 'a t -> f:(key -> 'a -> 'b option) -> 'b t
val of_list : (key * 'a) list -> 'a t
val disjoint_union :
module Make_map (T : Thing) = struct
include Map.Make (T)
- let filter_map t ~f =
- fold (fun id v map ->
- match f id v with
- | None -> map
- | Some r -> add id r map) t empty
-
let of_list l =
List.fold_left (fun map (id, v) -> add id v map) empty l
with type key = T.t
and type 'a t = 'a Map.Make (T).t
- val filter_map : 'a t -> f:(key -> 'a -> 'b option) -> 'b t
val of_list : (key * 'a) list -> 'a t
(** [disjoint_union m1 m2] contains all bindings from [m1] and
fun refs f ->
let backup = List.map (fun (R (r, _)) -> R (r, !r)) refs in
set_refs refs;
- match f () with
- | x -> set_refs backup; x
- | exception e -> set_refs backup; raise e
+ Fun.protect ~finally:(fun () -> set_refs backup) f
(* List functions *)
} in
pp_set_mark_tags ppf true; (* enable tags *)
pp_set_formatter_stag_functions ppf functions';
- (* also setup margins *)
- pp_set_margin ppf (pp_get_margin std_formatter());
()
external isatty : out_channel -> bool = "caml_sys_isatty"
loop !log
end
+
+
+module Magic_number = struct
+ type native_obj_config = {
+ flambda : bool;
+ }
+ let native_obj_config = {
+ flambda = Config.flambda;
+ }
+
+ type version = int
+
+ type kind =
+ | Exec
+ | Cmi | Cmo | Cma
+ | Cmx of native_obj_config | Cmxa of native_obj_config
+ | Cmxs
+ | Cmt
+ | Ast_impl | Ast_intf
+
+ (* please keep up-to-date, this is used for sanity checking *)
+ let all_native_obj_configs = [
+ {flambda = true};
+ {flambda = false};
+ ]
+ let all_kinds = [
+ Exec;
+ Cmi; Cmo; Cma;
+ ]
+ @ List.map (fun conf -> Cmx conf) all_native_obj_configs
+ @ List.map (fun conf -> Cmxa conf) all_native_obj_configs
+ @ [
+ Cmt;
+ Ast_impl; Ast_intf;
+ ]
+
+ type raw = string
+ type info = {
+ kind: kind;
+ version: version;
+ }
+
+ type raw_kind = string
+
+ let parse_kind : raw_kind -> kind option = function
+ | "Caml1999X" -> Some Exec
+ | "Caml1999I" -> Some Cmi
+ | "Caml1999O" -> Some Cmo
+ | "Caml1999A" -> Some Cma
+ | "Caml1999y" -> Some (Cmx {flambda = true})
+ | "Caml1999Y" -> Some (Cmx {flambda = false})
+ | "Caml1999z" -> Some (Cmxa {flambda = true})
+ | "Caml1999Z" -> Some (Cmxa {flambda = false})
+
+ (* Caml2007D and Caml2012T were used instead of the common Caml1999 prefix
+ between the introduction of those magic numbers and October 2017
+ (8ba70ff194b66c0a50ffb97d41fe9c4bdf9362d6).
+
+ We accept them here, but will always produce/show kind prefixes
+ that follow the current convention, Caml1999{D,T}. *)
+ | "Caml2007D" | "Caml1999D" -> Some Cmxs
+ | "Caml2012T" | "Caml1999T" -> Some Cmt
+
+ | "Caml1999M" -> Some Ast_impl
+ | "Caml1999N" -> Some Ast_intf
+ | _ -> None
+
+ (* note: over time the magic kind number has changed for certain kinds;
+ this function returns them as they are produced by the current compiler,
+ but [parse_kind] accepts older formats as well. *)
+ let raw_kind : kind -> raw = function
+ | Exec -> "Caml1999X"
+ | Cmi -> "Caml1999I"
+ | Cmo -> "Caml1999O"
+ | Cma -> "Caml1999A"
+ | Cmx config ->
+ if config.flambda
+ then "Caml1999y"
+ else "Caml1999Y"
+ | Cmxa config ->
+ if config.flambda
+ then "Caml1999z"
+ else "Caml1999Z"
+ | Cmxs -> "Caml1999D"
+ | Cmt -> "Caml1999T"
+ | Ast_impl -> "Caml1999M"
+ | Ast_intf -> "Caml1999N"
+
+ let string_of_kind : kind -> string = function
+ | Exec -> "exec"
+ | Cmi -> "cmi"
+ | Cmo -> "cmo"
+ | Cma -> "cma"
+ | Cmx _ -> "cmx"
+ | Cmxa _ -> "cmxa"
+ | Cmxs -> "cmxs"
+ | Cmt -> "cmt"
+ | Ast_impl -> "ast_impl"
+ | Ast_intf -> "ast_intf"
+
+ let human_description_of_native_obj_config : native_obj_config -> string =
+ fun[@warning "+9"] {flambda} ->
+ if flambda then "flambda" else "non flambda"
+
+ let human_name_of_kind : kind -> string = function
+ | Exec -> "executable"
+ | Cmi -> "compiled interface file"
+ | Cmo -> "bytecode object file"
+ | Cma -> "bytecode library"
+ | Cmx config ->
+ Printf.sprintf "native compilation unit description (%s)"
+ (human_description_of_native_obj_config config)
+ | Cmxa config ->
+ Printf.sprintf "static native library (%s)"
+ (human_description_of_native_obj_config config)
+ | Cmxs -> "dynamic native library"
+ | Cmt -> "compiled typedtree file"
+ | Ast_impl -> "serialized implementation AST"
+ | Ast_intf -> "serialized interface AST"
+
+ let kind_length = 9
+ let version_length = 3
+ let magic_length =
+ kind_length + version_length
+
+ type parse_error =
+ | Truncated of string
+ | Not_a_magic_number of string
+
+ let explain_parse_error kind_opt error =
+ Printf.sprintf
+ "We expected a valid %s, but the file %s."
+ (Option.fold ~none:"object file" ~some:human_name_of_kind kind_opt)
+ (match error with
+ | Truncated "" -> "is empty"
+ | Truncated _ -> "is truncated"
+ | Not_a_magic_number _ -> "has a different format")
+
+ let parse s : (info, parse_error) result =
+ if String.length s = magic_length then begin
+ let raw_kind = String.sub s 0 kind_length in
+ let raw_version = String.sub s kind_length version_length in
+ match parse_kind raw_kind with
+ | None -> Error (Not_a_magic_number s)
+ | Some kind ->
+ begin match int_of_string raw_version with
+ | exception _ -> Error (Truncated s)
+ | version -> Ok { kind; version }
+ end
+ end
+ else begin
+ (* a header is "truncated" if it starts like a valid magic number,
+ that is if its longest segment of length at most [kind_length]
+ is a prefix of [raw_kind kind] for some kind [kind] *)
+ let sub_length = min kind_length (String.length s) in
+ let starts_as kind =
+ String.sub s 0 sub_length = String.sub (raw_kind kind) 0 sub_length
+ in
+ if List.exists starts_as all_kinds then Error (Truncated s)
+ else Error (Not_a_magic_number s)
+ end
+
+ let read_info ic =
+ let header = Buffer.create magic_length in
+ begin
+ try Buffer.add_channel header ic magic_length
+ with End_of_file -> ()
+ end;
+ parse (Buffer.contents header)
+
+ let raw { kind; version; } =
+ Printf.sprintf "%s%03d" (raw_kind kind) version
+
+ let current_raw kind =
+ let open Config in
+ match[@warning "+9"] kind with
+ | Exec -> exec_magic_number
+ | Cmi -> cmi_magic_number
+ | Cmo -> cmo_magic_number
+ | Cma -> cma_magic_number
+ | Cmx config ->
+ (* the 'if' guarantees that in the common case
+ we return the "trusted" value from Config. *)
+ let reference = cmx_magic_number in
+ if config = native_obj_config then reference
+ else
+ (* otherwise we stitch together the magic number
+ for a different configuration by concatenating
+ the right magic kind at this configuration
+ and the rest of the current raw number for our configuration. *)
+ let raw_kind = raw_kind kind in
+ let len = String.length raw_kind in
+ raw_kind ^ String.sub reference len (String.length reference - len)
+ | Cmxa config ->
+ let reference = cmxa_magic_number in
+ if config = native_obj_config then reference
+ else
+ let raw_kind = raw_kind kind in
+ let len = String.length raw_kind in
+ raw_kind ^ String.sub reference len (String.length reference - len)
+ | Cmxs -> cmxs_magic_number
+ | Cmt -> cmt_magic_number
+ | Ast_intf -> ast_intf_magic_number
+ | Ast_impl -> ast_impl_magic_number
+
+ (* it would seem more direct to define current_version with the
+ correct numbers and current_raw on top of it, but for now we
+ consider the Config.foo values to be ground truth, and don't want
+ to trust the present module instead. *)
+ let current_version kind =
+ let raw = current_raw kind in
+ try int_of_string (String.sub raw kind_length version_length)
+ with _ -> assert false
+
+ type 'a unexpected = { expected : 'a; actual : 'a }
+ type unexpected_error =
+ | Kind of kind unexpected
+ | Version of kind * version unexpected
+
+ let explain_unexpected_error = function
+ | Kind { actual; expected } ->
+ Printf.sprintf "We expected a %s (%s) but got a %s (%s) instead."
+ (human_name_of_kind expected) (string_of_kind expected)
+ (human_name_of_kind actual) (string_of_kind actual)
+ | Version (kind, { actual; expected }) ->
+ Printf.sprintf "This seems to be a %s (%s) for %s version of OCaml."
+ (human_name_of_kind kind) (string_of_kind kind)
+ (if actual < expected then "an older" else "a newer")
+
+ let check_current expected_kind { kind; version } : _ result =
+ if kind <> expected_kind then begin
+ let actual, expected = kind, expected_kind in
+ Error (Kind { actual; expected })
+ end else begin
+ let actual, expected = version, current_version kind in
+ if actual <> expected
+ then Error (Version (kind, { actual; expected }))
+ else Ok ()
+ end
+
+ type error =
+ | Parse_error of parse_error
+ | Unexpected_error of unexpected_error
+
+ let read_current_info ~expected_kind ic =
+ match read_info ic with
+ | Error err -> Error (Parse_error err)
+ | Ok info ->
+ let kind = Option.value ~default:info.kind expected_kind in
+ match check_current kind info with
+ | Error err -> Error (Unexpected_error err)
+ | Ok () -> Ok info
+end
val protect_refs : ref_and_value list -> (unit -> 'a) -> 'a
(** [protect_refs l f] temporarily sets [r] to [v] for each [R (r, v)] in [l]
while executing [f]. The previous contents of the references is restored
- even if [f] raises an exception. *)
+ even if [f] raises an exception, without altering the exception backtrace.
+*)
module Stdlib : sig
module List : sig
val backtrack : log -> unit
end
+
+
+module Magic_number : sig
+ (** a typical magic number is "Caml1999I011"; it is formed of an
+ alphanumeric prefix, here Caml1990I, followed by a version,
+ here 011. The prefix identifies the kind of the versioned data:
+ here the I indicates that it is the magic number for .cmi files.
+
+ All magic numbers have the same byte length, [magic_length], and
+ this is important for users as it gives them the number of bytes
+ to read to obtain the byte sequence that should be a magic
+ number. Typical user code will look like:
+ {[
+ let ic = open_in_bin path in
+ let magic =
+ try really_input_string ic Magic_number.magic_length
+ with End_of_file -> ... in
+ match Magic_number.parse magic with
+ | Error parse_error -> ...
+ | Ok info -> ...
+ ]}
+
+ A given compiler version expects one specific version for each
+ kind of object file, and will fail if given an unsupported
+ version. Because versions grow monotonically, you can compare
+ the parsed version with the expected "current version" for
+ a kind, to tell whether the wrong-magic object file comes from
+ the past or from the future.
+
+ An example of code block that expects the "currently supported version"
+ of a given kind of magic numbers, here [Cmxa], is as follows:
+ {[
+ let ic = open_in_bin path in
+ begin
+ try Magic_number.(expect_current Cmxa (get_info ic)) with
+ | Parse_error error -> ...
+ | Unexpected error -> ...
+ end;
+ ...
+ ]}
+
+ Parse errors distinguish inputs that are [Not_a_magic_number str],
+ which are likely to come from the file being completely
+ different, and [Truncated str], raised by headers that are the
+ (possibly empty) prefix of a valid magic number.
+
+ Unexpected errors correspond to valid magic numbers that are not
+ the one expected, either because it corresponds to a different
+ kind, or to a newer or older version.
+
+ The helper functions [explain_parse_error] and [explain_unexpected_error]
+ will generate a textual explanation of each error,
+ for use in error messages.
+
+ @since 4.11.0
+ *)
+
+ type native_obj_config = {
+ flambda : bool;
+ }
+ (** native object files have a format and magic number that depend
+ on certain native-compiler configuration parameters. This
+ configuration space is expressed by the [native_obj_config]
+ type. *)
+
+ val native_obj_config : native_obj_config
+ (** the native object file configuration of the active/configured compiler. *)
+
+ type version = int
+
+ type kind =
+ | Exec
+ | Cmi | Cmo | Cma
+ | Cmx of native_obj_config | Cmxa of native_obj_config
+ | Cmxs
+ | Cmt | Ast_impl | Ast_intf
+
+ type info = {
+ kind: kind;
+ version: version;
+ (** Note: some versions of the compiler use the same [version] suffix
+ for all kinds, but others use different versions counters for different
+ kinds. We may only assume that versions are growing monotonically
+ (not necessarily always by one) between compiler versions. *)
+ }
+
+ type raw = string
+ (** the type of raw magic numbers,
+ such as "Caml1999A027" for the .cma files of OCaml 4.10 *)
+
+ (** {3 Parsing magic numbers} *)
+
+ type parse_error =
+ | Truncated of string
+ | Not_a_magic_number of string
+
+ val explain_parse_error : kind option -> parse_error -> string
+ (** Produces an explanation for a parse error. If no kind is provided,
+ we use an unspecific formulation suggesting that any compiler-produced
+ object file would have been satisfying. *)
+
+ val parse : raw -> (info, parse_error) result
+ (** Parses a raw magic number *)
+
+ val read_info : in_channel -> (info, parse_error) result
+ (** Read a raw magic number from an input channel.
+
+ If the data read [str] is not a valid magic number, it can be
+ recovered from the [Truncated str | Not_a_magic_number str]
+ payload of the [Error parse_error] case.
+
+ If parsing succeeds with an [Ok info] result, we know that
+ exactly [magic_length] bytes have been consumed from the
+ input_channel.
+
+ If you also wish to enforce that the magic number
+ is at the current version, see {!read_current_info} below.
+ *)
+
+ val magic_length : int
+ (** all magic numbers take the same number of bytes *)
+
+
+ (** {3 Checking that magic numbers are current} *)
+
+ type 'a unexpected = { expected : 'a; actual : 'a }
+ type unexpected_error =
+ | Kind of kind unexpected
+ | Version of kind * version unexpected
+
+ val check_current : kind -> info -> (unit, unexpected_error) result
+ (** [check_current kind info] checks that the provided magic [info]
+ is the current version of [kind]'s magic header. *)
+
+ val explain_unexpected_error : unexpected_error -> string
+ (** Provides an explanation of the [unexpected_error]. *)
+
+ type error =
+ | Parse_error of parse_error
+ | Unexpected_error of unexpected_error
+
+ val read_current_info :
+ expected_kind:kind option -> in_channel -> (info, error) result
+ (** Read a magic number as [read_info],
+ and check that it is the current version as its kind.
+ If the [expected_kind] argument is [None], any kind is accepted. *)
+
+
+ (** {3 Information on magic numbers} *)
+
+ val string_of_kind : kind -> string
+ (** a user-printable string for a kind, eg. "exec" or "cmo", to use
+ in error messages. *)
+
+ val human_name_of_kind : kind -> string
+ (** a user-meaningful name for a kind, eg. "executable file" or
+ "bytecode object file", to use in error messages. *)
+
+ val current_raw : kind -> raw
+ (** the current magic number of each kind *)
+
+ val current_version : kind -> version
+ (** the current version of each kind *)
+
+
+ (** {3 Raw representations}
+
+ Mainly for internal usage and testing. *)
+
+ type raw_kind = string
+ (** the type of raw magic numbers kinds,
+ such as "Caml1999A" for .cma files *)
+
+ val parse_kind : raw_kind -> kind option
+ (** parse a raw kind into a kind *)
+
+ val raw_kind : kind -> raw_kind
+ (** the current raw representation of a kind.
+
+ In some cases the raw representation of a kind has changed
+ over compiler versions, so other files of the same kind
+ may have different raw kinds.
+ Note that all currently known cases are parsed correctly by [parse_kind].
+ *)
+
+ val raw : info -> raw
+ (** A valid raw representation of the magic number.
+
+ Due to past and future changes in the string representation of
+ magic numbers, we cannot guarantee that the raw strings returned
+ for past and future versions actually match the expectations of
+ those compilers. The representation is accurate for current
+ versions, and it is correctly parsed back into the desired
+ version by the parsing functions above.
+ *)
+
+ (**/**)
+
+ val all_kinds : kind list
+end
let rec zero_to_n n =
if n < 0 then Set.empty else Set.add n (zero_to_n (n-1))
+
+ let to_string n = Int.to_string n
end
module Int8 = struct
(** [zero_to_n n] is the set of numbers \{0, ..., n\} (inclusive). *)
val zero_to_n : int -> Set.t
+ val to_string : int -> string
end
module Int8 : sig
[
1, "Suspicious-looking start-of-comment mark.";
2, "Suspicious-looking end-of-comment mark.";
- 3, "Deprecated synonym for the 'deprecated' alert";
+ 3, "Deprecated synonym for the 'deprecated' alert.";
4, "Fragile pattern matching: matching that will remain complete even\n\
\ if additional constructors are added to one of the variant types\n\
\ matched.";
50, "Unexpected documentation comment.";
51, "Warning on non-tail calls if @tailcall present.";
52, "Fragile constant pattern.";
- 53, "Attribute cannot appear in this context";
- 54, "Attribute used more than once on an expression";
- 55, "Inlining impossible";
+ 53, "Attribute cannot appear in this context.";
+ 54, "Attribute used more than once on an expression.";
+ 55, "Inlining impossible.";
56, "Unreachable case in a pattern-matching (based on type information).";
- 57, "Ambiguous or-pattern variables under guard";
- 58, "Missing cmx file";
- 59, "Assignment to non-mutable value";
- 60, "Unused module declaration";
- 61, "Unboxable type in primitive declaration";
- 62, "Type constraint on GADT type declaration";
- 63, "Erroneous printed signature";
- 64, "-unsafe used with a preprocessor returning a syntax tree";
- 65, "Type declaration defining a new '()' constructor";
- 66, "Unused open! statement";
+ 57, "Ambiguous or-pattern variables under guard.";
+ 58, "Missing cmx file.";
+ 59, "Assignment to non-mutable value.";
+ 60, "Unused module declaration.";
+ 61, "Unboxable type in primitive declaration.";
+ 62, "Type constraint on GADT type declaration.";
+ 63, "Erroneous printed signature.";
+ 64, "-unsafe used with a preprocessor returning a syntax tree.";
+ 65, "Type declaration defining a new '()' constructor.";
+ 66, "Unused open! statement.";
+ 67, "Unused functor parameter.";
]
;;
ROOTDIR = ..
-include $(ROOTDIR)/Makefile.config
-include $(ROOTDIR)/Makefile.common
+-include $(ROOTDIR)/Makefile.config
+-include $(ROOTDIR)/Makefile.common
OC_CPPFLAGS += -I$(ROOTDIR)/runtime
echo "#define OCAML_VERSION \"`sed -e 1q $< | tr -d '\r'`\"" > $@
clean:
- rm -f $(generated_files)
+ rm -f ocamlyacc ocamlyacc.exe wstr.o wstr.obj version.h \
+ $(ocamlyacc_SOURCES:.c=.o) $(ocamlyacc_SOURCES:.c=.obj)
depend:
short prec;
char class;
char assoc;
- char entry;
+ unsigned char entry; /* 1..MAX_ENTRY_POINT (0 for unassigned) */
char true_token;
};
+/* MAX_ENTRY_POINT is the maximal number of entry points into the grammar. */
+/* Entry points are identified by a non-zero byte in the input stream, */
+/* so there are at most 255 entry points. */
+
+#define MAX_ENTRY_POINT MAXCHAR
+
/* TABLE_SIZE is the number of entries in the symbol table. */
/* TABLE_SIZE must be a power of two. */
void too_many_entries(void)
{
- fprintf(stderr, "File \"%s\", line %d: more than 256 entry points\n",
- virtual_input_file_name, lineno);
+ fprintf(stderr, "File \"%s\", line %d: more than %u entry points\n",
+ virtual_input_file_name, lineno, MAX_ENTRY_POINT);
done(1);
}
static void process_open_curly_bracket(FILE *f) {
- if (In_bitmap(caml_ident_start, *cptr) || *cptr == '|')
+ char *idcptr = cptr;
+
+ if (*idcptr == '%') {
+ if (*++idcptr == '%') idcptr++;
+
+ if (In_bitmap(caml_ident_start, *idcptr)) {
+ idcptr++;
+ while (In_bitmap(caml_ident_body, *idcptr)) idcptr++;
+ while (*idcptr == '.') {
+ idcptr++;
+ if (In_bitmap(caml_ident_start, *idcptr)) {
+ idcptr++;
+ while (In_bitmap(caml_ident_body, *idcptr)) idcptr++;
+ }
+ }
+ while (*idcptr == ' ' || *idcptr == 9 || *idcptr == 12) idcptr++;
+ } else {
+ return;
+ }
+ }
+
+ if (In_bitmap(caml_ident_start, *idcptr) || *idcptr == '|')
{
- char *newcptr = cptr;
+ char *newcptr = idcptr;
size_t size = 0;
char *buf;
while(In_bitmap(caml_ident_body, *newcptr)) { newcptr++; }
char *s_line;
char *s_cptr;
- size = newcptr - cptr;
+ size = newcptr - idcptr;
buf = MALLOC(size + 2);
if (!buf) no_space();
- memcpy(buf, cptr, size);
+ memcpy(buf, idcptr, size);
buf[size] = '}';
buf[size + 1] = '\0';
- fwrite(cptr, 1, size + 1, f);
+ fwrite(cptr, 1, newcptr - cptr + 1, f);
cptr = newcptr + 1;
s_lineno = lineno;
s_line = dup_line();
continue;
default:
if (In_bitmap(caml_ident_start, c)) {
- while (In_bitmap(caml_ident_body, *cptr)) cptr++;
+ while (In_bitmap(caml_ident_body, *cptr)) putc(*cptr++, f);
}
continue;
}
if (bp->class == TERM)
terminal_start(bp->name);
- bp->entry = ++entry_counter;
- if (entry_counter == 256)
+ if (entry_counter >= MAX_ENTRY_POINT)
too_many_entries();
+ bp->entry = ++entry_counter;
}
}
if (is_polymorphic(bp->tag))
polymorphic_entry_point(bp->name);
fprintf(entry_file,
- "let %s (lexfun : Lexing.lexbuf -> token) (lexbuf : Lexing.lexbuf) =\n (Parsing.yyparse yytables %d lexfun lexbuf : %s)\n",
+ "let %s (lexfun : Lexing.lexbuf -> token) (lexbuf : Lexing.lexbuf) =\n (Parsing.yyparse yytables %u lexfun lexbuf : %s)\n",
bp->name, bp->entry, bp->tag);
fprintf(interface_file,
"val %s :\n (Lexing.lexbuf -> token) -> Lexing.lexbuf -> %s\n",
projects / ocaml.git / commitdiff